精华内容
下载资源
问答
  • 1.8 实时机器学习模型的生存期 进行实时机器学习开发必须考虑生存期。生存期是指一个系统从提出、设计、开发、 测试到部署运用、维护、更新升级或退役的整个过程。若在生存期设计上出现了数据,那么在后面的使用中...

    1.8 实时机器学习模型的生存期

    进行实时机器学习开发必须考虑生存期。生存期是指一个系统从提出、设计、开发、 测试到部署运用、维护、更新升级或退役的整个过程。若在生存期设计上出现了数据,那么在后面的使用中就会出现各种各样的瓶颈阻碍应用产生价值。
    从软件工程的角度上讲,开发实时机器学习也遵从构思、分析、设计、实现和维护五个步骤,这五个步骤可能会循环往复,随着业务的发展进行多次迭代。实时机器学习模型的应用由于其技术的特殊性,也具有自己的小型生存期,其中包括数据收集、数据分析、离线手工建模评测、上线自动化建模评测这四个方面。如图1-1所示,离线手工建模评测、上线自动化建模评测这两个部分主要是靠监督式机器学习。而数据分析主要是依靠非监督式机器学习和统计数据分析。

    screenshot

    值得一提的是,进行上面这四个步骤的前提是机器学习模型能够给组织和用户带来价值。但是,众多开发人员甚至是领导层都不愿意面对的一个问题是:我的模型真的有用吗?
    对于一些非机器学习大数据类的初创公司来说,在用户数量并不太多的情况下,用非监督式机器学习进行少量数据分析,然后用人力进行反馈,反而有可能会取得更优良的投资回报率。笔者道听途说得知国内一些门户视频网站,就算在公司都已经上市之后,仍然还在使用人工选择的方式进行视频推介,甚至还取得了尚可的效果。
    如果机器学习不能给组织带来直接效果,就算有高层支持,对于机器学习从业人员来说也不是很好的职业选择。在机器学习能为组织带来效益的情况下,让数据说话,从业人员才能够不断进行深挖,并得到更多的锻炼和领域洞见;与此相反,如果所建立的系统听起来很好,但是却没能带来相对应的效益,那么这样岗位上从业人员的工作重心就会像浮萍一样随波逐流,被公司政治利益驱动,长期来说这样很不利于从业人员的个人发展。
    机器学习实战的最高境界,就是知行合一,在创造科技前沿作品的同时,能够为个人、组织和社会带来效益,这也是本书写作的指导思想。
    在下面的章节里,我们将会从更实际的角度出发来探索实时机器学习的应用。其中,第2章到第4章,我们将会介绍监督式机器学习模型,并且学习建模的工具Pandas和Scikit-learn;第6章到第9章,我们将会介绍实时机器学习的架构,并且学习使用Docker、 RabbitMQ、Elasticsearch及数据库等重要组成部分。

    展开全文
  • 模型学习机) 学习算法 数据集 样本 属性(特征) 属性空间(特征空间)(样本空间) 样本维数 学习(训练) 训练数据:训练过程使用的数据 训练样本:训练数据中的每一个样本 训练集:训练样本组成的...

    4_21笔记
    模型(学习机)
    学习算法
    数据集
    样本
    属性(特征)
    属性空间(特征空间)(样本空间)
    样本维数
    学习(训练)
    训练数据:训练过程使用的数据
    训练样本:训练数据中的每一个样本
    训练集:训练样本组成的集合
    假设
    真相(事实)
    标记(label)
    样例(拥有了标记信息的事例)
    标记空间(样本空间)
    分类:预测的是离散值
    回归:预测的是连续值
    正类、反类:对于二分类问题,一个类为正类,另一个为反类
    多分类任务
    测试:学得模型以后,使用其进行预测的过程
    测试样本:预测过程中被预测的样本
    聚类

    监督学习:分类和回归
    无监督学习:聚类
    泛化能力:学得模型适用于新样本的能力
    分布
    独立同分布
    归纳:从特殊到一般的泛化过程,即从具体的事实归结出一般性规律,从样例中学习,即归纳学习
    推理:从一般到特殊的特化过程,即从基础原理推演出具体状况,基于一组公理和推理规则推导出与之相洽的定理
    广义归纳:从样例中学习
    狭义归纳:从训练数据中学得概念,亦称为概念学习或概念形成
    布尔概念学习
    假设
    假设匹配
    假设空间
    版本空间:与训练集一致的假设集合
    偏好(归纳偏好):机器学习算法在学习过程中对某种类型假设的偏好
    奥卡姆剃刀原则:若有多个假设与观察一致,则选择最简单的那个
    没有免费的午餐定理(NFL):无论哪个算法,他们的期望性能都相同,告诉我们谈论算法的相对优劣,必须要针对具体的学习问题
    错误率:分类错误的样本数占样本总数的比率,设错误样本a,总样本m. 错误率是a/m*100%
    精度:1-错误率 即1-a/m
    误差:学习机的实际预测输出与样本的真实输出之间的差异称为误差
    训练误差(经验误差):学习机在训练集上的误差称为训练误差(经验误差)
    泛化误差:在新样本上的误差
    过拟合:学习机把训练样本学得“太好”,,把训练样本的自身的一些特点当作了所有潜在样本的普遍规律,导致泛化能力下降
    欠拟合:对训练样本的一般性质尚未学好
    NP:多项式非确定性问题,只要P不等于NP,过拟合是无法避免的
    模型选择问题
    测试集:用来测试学习机对新样本的判别能力,通常假设测试样本也是从样本真实分布中独立同分布采样而得,应尽可能与顺连集互斥,即测试样本尽量不在训练集中出现,未在训练过程中使用过
    测试误差:泛化误差的近似
    留出法:直接将训练集D划分成两个互斥的集合,其中一个集合作为训练集S,另一个作为测试集T,由于单次使用留出法得到的估计结果往往不够稳定可靠,在使用留出法的时候,一般采用若干次随机划分、重复进行试验评估后取平均值作为留出法的评估结果
    交叉验证法(K折交叉验证):先将数据集D划分为K个大小相似的互斥子集,每个子集尽可能保持数据分布的一致性,即从D中通过分层采样得到,然后,每次将K-I个子集作为训练集,剩下的一个子集作为测试集,然后就获得了K组训练/测试集,从而可以进行K次训练和测试,最终返回的是这K个测试结果的均值(K常用取10,此时叫10折交叉验证,其他常用的有5,20等),将测试集D划分为K个子集同样有多种方式,因此采用不同的划分方法重复p次,这时叫p次K折交叉验证
    留一法(LOO):交叉验证法特例,假定数据集D包含m个样本,令K=m
    自助法:以自助采样法为基准,给定包含m个样本的数据集D,对它进行有放回的采样m个样本产生数据集D‘,用D’作为训练集,用D\D’(\表示减法)作为测试集,这样就排除了因训练样本规模不同导致的估计偏差,在数据集较小、难以有效划分训练/测试集时很有用,但改变了初始数据集的分布
    包外估计:自助法这样的,实际评估模型与期望评估的模型都使用m个训练样本,而仍有没在训练集中出现过的样本用于测试的测试结果
    验证集:模型评估与选择中用于评估测试的数据集常称为验证集
    性能度量:衡量模型泛化能力的评价标准回归任务最常用的性能度量是均方误差
    错误率与精度
    查准率、查全率与F1:真正例TP,假反例FN,假正例FP,真反例TN,查准率P=TP/(TP+FP),查全率R=TP/(TP+FN)查准率和查全率是一对矛盾的度量
    P-R曲线
    平衡点(BEP):P-R曲线上查准率= 查全率时的取值
    F1度量:beta>1时查全率有更大影响,beta<1时查准率有更大影响
    宏查准率、宏查全率、宏F1
    微查准率、微查全率、微F1
    受试者工作特征(ROC):ROC曲线,研究学习机泛化性能的工具,ROC和AUC详解
    真正例率(TPR):TPR=TP/(TP+FN)
    假正例率(FPR):FPR=FP/(TN+FP)
    AUC:随机挑选一个正样本以及一个负样本,当前的分类算法根据计算得到的Score值将这个正样本排在负样本前面的概率就是AUC值。这里的score值就是预测为正的概率的值,排在前面表示的是正样本的预测为正的概率值大于负样本的预测为正的概率值。计算是ROS曲线的面积
    非均等代价
    代价矩阵
    代价曲线:书上说的太少,理解起来有难度,这个博客讲的明白
    统计假设检验:试验估计泛化性能
    泛化误差:可分解为偏差、方差、噪声之和
    偏差:度量了学习算法的期望预测与真实结果的偏离程度,刻画了学习算法本身的拟合能力
    方差:度量了同样大小数据集的变动导致的学习性能的变化,即刻画了数据扰动所造成的影响
    噪声:表达了在当前任务上任何学习算法所能达到的期望泛化误差的下界,刻画了学习问题本身的难度
    偏差-方差窘境
    线性模型
    离散属性连续化
    均方误差(平方损失)
    欧式距离
    最小二乘法:基于均方误差最小化来进行模型求解的方法
    参数估计
    多元线性回归:考虑多个属性
    正则化项
    对数线性回归
    广义线性模型
    对数几率回归
    极大似然法
    线性判别分析

    展开全文
  • 当部署的机器学习模型已经服务于业务时,如何在飞转的引擎下对其进行实时更新,且做到不停机?这是在机器学习应用领域绕不过去的问题,我们知道生产应用中的模型经常会更新,对于营销类的模型变化更快,更新频率经常...

    add7116dd7c5f639e6d47897490952a0.png

    当部署的机器学习模型已经服务于业务时,如何在飞转的引擎下对其进行实时更新,且做到不停机?这是在机器学习应用领域绕不过去的问题,我们知道生产应用中的模型经常会更新,对于营销类的模型变化更快,更新频率经常是小时级或更频繁,那么模型的热部署和版本的自动切换会显得非常关键。

    容易想到的方案:只要从POST请求中加载一个新的模型,对不?这看起来是一个简单、合适的方法,但实施关键在理解框架运作原理。

    本文将介绍如何让基于Flask应用程序在线更新模型到生产中的步骤。首先,我们将考虑这种方法用于一个单线程的Flask应用程序。接下来,我们将在Web服务器网关接口(WSGI)后面部署它,并发现仍有不足之处。然后,我们将为模型更新添加一个进程锁,以确保在我们的应用程序更新时,其他进程继续提供响应。最后,我们将讨论通过Kubernetes将我们的WSGI进程锁解决方案扩展到多个服务器。

    我们需要的不仅仅是一个Flask应用

    Flask是最流行的REST API框架之一,可以用于托管机器学习(ML)模型。这一选择在很大程度上受到数据科学团队在Python方面的专业知识和用Python构建的训练资源的可重用性的影响。当前市场上数据科学团队广泛使用 Flask 来服务于各种 ML 模型的预测。然而,在Flask应用为生产准备之前,需要考虑一些问题,比如性能。

    如果Flask代码没有被修改为异步运行,那么每次每个进程只能运行一个请求。当您从本地开发扩展到每秒数百个或数千个请求(rps)的生产负载时,这可能会变成一个问题。将Flask应用产品化的第一步是将其置于WSGI后端,WSGI可以生成和管理线程/进程。这篇文章将详细介绍uWSGI的配置,但其他框架也是可用的,如Gunicorn和Gevent。

    GIL、线程和进程的入门知识

    Python 使用全局解释器锁 (GIL) 来防止多个线程同时执行 Python 字节码。GIL在I/O操作上被释放,包括等待套接字和文件系统的读写。因此,在某些情况下,线程可以带来性能的提升。如果一个操作不重I/O,过多的线程会造成GIL瓶颈。在这种情况下,Python中更高的并发性是通过使用多个并行进程实现的。

    将Flask应用程序放置在WSGI后面,将允许您通过进程和/或线程来增加并发性。对于uWSGI,Flask应用程序将根据配置中声明的线程和进程数量进行部署。因为ML预测通常不会从线程中获益,所以我们设置线程数=1,并通过多个进程获得我们的并发性。运行多个进程确实会带来副作用:我们需要为每个进程保留应用内存,而且进程之间不能显式通信(这就意味着模型部署在多个进程的时候,更新模型时需要将每个进程内的模型都要进行更新,否则会出现新模型与旧模型并存的情况)。

    模型更新功能结构

    生产flask的后端原理:

    0d21a05bb9436159ad6090f08c1ae551.png

    更新原理

    ee88541a43b96c50debcfd97d86ec65b.png

    未完待续......

    展开全文
  • Spark机器学习 1 在线学习 模型随着接收的新消息,不断更新自己;而不是像离线训练一次次重新训练。 2 Spark Streaming 离散化流(DStream) 输入源:Akka actors、消息队列、Flume、Kafka、…… ...


    Spark机器学习

    1 在线学习

    模型随着接收的新消息,不断更新自己;而不是像离线训练一次次重新训练。

    2 Spark Streaming

    • 离散化流(DStream)
    • 输入源:Akka actors、消息队列、Flume、Kafka、……
      streaming_arch

    http://spark.apache.org/docs/latest/streaming-programming-guide.html

    • 类群(lineage):应用到RDD上的转换算子和执行算子的集合

    3 MLib+Streaming应用

    3.0 build.sbt

    依赖Spark MLlib和Spark Streaming

    name := "scala-spark-streaming-app"
    
    version := "1.0"
    
    scalaVersion := "2.11.7"
    
    libraryDependencies += "org.apache.spark" %% "spark-mllib" % "1.5.1"
    
    libraryDependencies += "org.apache.spark" %% "spark-streaming" % "1.5.1"
    使用国内镜像仓库

    ~/.sbt/repositories

    [repositories]
    local
    osc: http://maven.oschina.net/content/groups/public/
    typesafe: http://repo.typesafe.com/typesafe/ivy-releases/, [organization]/[module]/(scala_[scalaVersion]/)(sbt_[sbtVersion]/)[revision]/[type]s/[artifact](-[classifier]).[ext], bootOnly
    sonatype-oss-releases
    maven-central
    sonatype-oss-snapshots

    3.1 生产消息

    object StreamingProducer {
    
      def main(args: Array[String]) {
    
        val random = new Random()
    
        // Maximum number of events per second
        val MaxEvents = 6
    
        // Read the list of possible names
        val namesResource = this.getClass.getResourceAsStream("/names.csv")
        val names = scala.io.Source.fromInputStream(namesResource)
          .getLines()
          .toList
          .head
          .split(",")
          .toSeq
    
        // Generate a sequence of possible products
        val products = Seq(
          "iPhone Cover" -> 9.99,
          "Headphones" -> 5.49,
          "Samsung Galaxy Cover" -> 8.95,
          "iPad Cover" -> 7.49
        )
    
        /** Generate a number of random product events */
        def generateProductEvents(n: Int) = {
          (1 to n).map { i =>
            val (product, price) = products(random.nextInt(products.size))
            val user = random.shuffle(names).head
            (user, product, price)
          }
        }
    
        // create a network producer
        val listener = new ServerSocket(9999)
        println("Listening on port: 9999")
    
        while (true) {
          val socket = listener.accept()
          new Thread() {
            override def run = {
              println("Got client connected from: " + socket.getInetAddress)
              val out = new PrintWriter(socket.getOutputStream(), true)
    
              while (true) {
                Thread.sleep(1000)
                val num = random.nextInt(MaxEvents)
                val productEvents = generateProductEvents(num)
                productEvents.foreach{ event =>
                  out.write(event.productIterator.mkString(","))
                  out.write("\n")
                }
                out.flush()
                println(s"Created $num events...")
              }
              socket.close()
            }
          }.start()
        }
      }
    }
    sbt run
    
    Multiple main classes detected, select one to run:
    
     [1] MonitoringStreamingModel
     [2] SimpleStreamingApp
     [3] SimpleStreamingModel
     [4] StreamingAnalyticsApp
     [5] StreamingModelProducer
     [6] StreamingProducer
     [7] StreamingStateApp
    
    Enter number: 6

    3.2 打印消息

    object SimpleStreamingApp {
      def main(args: Array[String]) {
        val ssc = new StreamingContext("local[2]", "First Streaming App", Seconds(10))
        val stream = ssc.socketTextStream("localhost", 9999)
        // here we simply print out the first few elements of each batch
        stream.print()
        ssc.start()
        ssc.awaitTermination()
      }
    }
    sbt run
    
    Enter number: 2

    3.3 流式分析

    object StreamingAnalyticsApp {
      def main(args: Array[String]) {
        val ssc = new StreamingContext("local[2]", "First Streaming App", Seconds(10))
        val stream = ssc.socketTextStream("localhost", 9999)
    
        // create stream of events from raw text elements
        val events = stream.map { record =>
          val event = record.split(",")
          (event(0), event(1), event(2))
        }
    
        /*
          We compute and print out stats for each batch.
          Since each batch is an RDD, we call forEeachRDD on the DStream, and apply the usual RDD functions
          we used in Chapter 1.
         */
        events.foreachRDD { (rdd, time) =>
          val numPurchases = rdd.count()
          val uniqueUsers = rdd.map { case (user, _, _) => user }.distinct().count()
          val totalRevenue = rdd.map { case (_, _, price) => price.toDouble }.sum()
          val productsByPopularity = rdd
            .map { case (user, product, price) => (product, 1) }
            .reduceByKey(_ + _)
            .collect()
            .sortBy(-_._2)
          val mostPopular = productsByPopularity(0)
    
          val formatter = new SimpleDateFormat
          val dateStr = formatter.format(new Date(time.milliseconds))
          println(s"== Batch start time: $dateStr ==")
          println("Total purchases: " + numPurchases)
          println("Unique users: " + uniqueUsers)
          println("Total revenue: " + totalRevenue)
          println("Most popular product: %s with %d purchases".format(mostPopular._1, mostPopular._2))
        }
    
        // start the context
        ssc.start()
        ssc.awaitTermination()
      }
    }
    sbt run
    
    Enter number: 4

    3.4 有状态的流计算

    object StreamingStateApp {
    
      import org.apache.spark.streaming.StreamingContext._
    
      def updateState(prices: Seq[(String, Double)], currentTotal: Option[(Int, Double)]) = {
        val currentRevenue = prices.map(_._2).sum
        val currentNumberPurchases = prices.size
        val state = currentTotal.getOrElse((0, 0.0))
        Some((currentNumberPurchases + state._1, currentRevenue + state._2))
      }
    
      def main(args: Array[String]) {
        val ssc = new StreamingContext("local[2]", "First Streaming App", Seconds(10))
        // for stateful operations, we need to set a checkpoint location
        ssc.checkpoint("/tmp/sparkstreaming/")
        val stream = ssc.socketTextStream("localhost", 9999)
        // create stream of events from raw text elements
        val events = stream.map { record =>
          val event = record.split(",")
          (event(0), event(1), event(2).toDouble)
        }
        val users = events.map { case (user, product, price) => (user, (product, price)) }
        val revenuePerUser = users.updateStateByKey(updateState)
        revenuePerUser.print()
        // start the context
        ssc.start()
        ssc.awaitTermination()
      }
    }
    sbt run
    
    Enter number: 7

    4 线性流回归

    线性回归StreamingLinearRegressionWithSGD

    • trainOn
    • predictOn

    4.1 流数据生成器

    object StreamingModelProducer {
    
      import breeze.linalg._
    
      def main(args: Array[String]) {
        // Maximum number of events per second
        val MaxEvents = 100
        val NumFeatures = 100
        val random = new Random()
    
        /** Function to generate a normally distributed dense vector */
        def generateRandomArray(n: Int) = Array.tabulate(n)(_ => random.nextGaussian())
    
        // Generate a fixed random model weight vector
        val w = new DenseVector(generateRandomArray(NumFeatures))
        val intercept = random.nextGaussian() * 10
    
        /** Generate a number of random product events */
        def generateNoisyData(n: Int) = {
          (1 to n).map { i =>
            val x = new DenseVector(generateRandomArray(NumFeatures))
            val y: Double = w.dot(x)
            val noisy = y + intercept //+ 0.1 * random.nextGaussian()
            (noisy, x)
          }
        }
    
        // create a network producer
        val listener = new ServerSocket(9999)
        println("Listening on port: 9999")
    
        while (true) {
          val socket = listener.accept()
          new Thread() {
            override def run = {
              println("Got client connected from: " + socket.getInetAddress)
              val out = new PrintWriter(socket.getOutputStream(), true)
    
              while (true) {
                Thread.sleep(1000)
                val num = random.nextInt(MaxEvents)
                val data = generateNoisyData(num)
                data.foreach { case (y, x) =>
                  val xStr = x.data.mkString(",")
                  val eventStr = s"$y\t$xStr"
                  out.write(eventStr)
                  out.write("\n")
                }
                out.flush()
                println(s"Created $num events...")
              }
              socket.close()
            }
          }.start()
        }
      }
    }
    sbt run
    
    Enter number: 5

    4.2 流回归模型

    object SimpleStreamingModel {
      def main(args: Array[String]) {
        val ssc = new StreamingContext("local[2]", "First Streaming App", Seconds(10))
        val stream = ssc.socketTextStream("localhost", 9999)
    
        val NumFeatures = 100
        val zeroVector = DenseVector.zeros[Double](NumFeatures)
        val model = new StreamingLinearRegressionWithSGD()
          .setInitialWeights(Vectors.dense(zeroVector.data))
          .setNumIterations(1)
          .setStepSize(0.01)
    
        // create a stream of labeled points
        val labeledStream: DStream[LabeledPoint] = stream.map { event =>
          val split = event.split("\t")
          val y = split(0).toDouble
          val features: Array[Double] = split(1).split(",").map(_.toDouble)
          LabeledPoint(label = y, features = Vectors.dense(features))
        }
    
        // train and test model on the stream, and print predictions for illustrative purposes
        model.trainOn(labeledStream)
        //model.predictOn(labeledStream).print()
    
        ssc.start()
        ssc.awaitTermination()
      }
    }
    sbt run
    
    Enter number: 5

    5 流K-均值

    • K-均值聚类:StreamingKMeans

    6 评估

    object MonitoringStreamingModel {
      def main(args: Array[String]) {
        val ssc = new StreamingContext("local[2]", "First Streaming App", Seconds(10))
        val stream = ssc.socketTextStream("localhost", 9999)
    
        val NumFeatures = 100
        val zeroVector = DenseVector.zeros[Double](NumFeatures)
        val model1 = new StreamingLinearRegressionWithSGD()
          .setInitialWeights(Vectors.dense(zeroVector.data))
          .setNumIterations(1)
          .setStepSize(0.01)
    
        val model2 = new StreamingLinearRegressionWithSGD()
          .setInitialWeights(Vectors.dense(zeroVector.data))
          .setNumIterations(1)
          .setStepSize(1.0)
    
        // create a stream of labeled points
        val labeledStream = stream.map { event =>
          val split = event.split("\t")
          val y = split(0).toDouble
          val features = split(1).split(",").map(_.toDouble)
          LabeledPoint(label = y, features = Vectors.dense(features))
        }
    
        // train both models on the same stream
        model1.trainOn(labeledStream)
        model2.trainOn(labeledStream)
    
        // use transform to create a stream with model error rates
        val predsAndTrue = labeledStream.transform { rdd =>
          val latest1 = model1.latestModel()
          val latest2 = model2.latestModel()
          rdd.map { point =>
            val pred1 = latest1.predict(point.features)
            val pred2 = latest2.predict(point.features)
            (pred1 - point.label, pred2 - point.label)
          }
        }
    
        // print out the MSE and RMSE metrics for each model per batch
        predsAndTrue.foreachRDD { (rdd, time) =>
          val mse1 = rdd.map { case (err1, err2) => err1 * err1 }.mean()
          val rmse1 = math.sqrt(mse1)
          val mse2 = rdd.map { case (err1, err2) => err2 * err2 }.mean()
          val rmse2 = math.sqrt(mse2)
          println(
            s"""
               |-------------------------------------------
               |Time: $time
               |-------------------------------------------
             """.stripMargin)
          println(s"MSE current batch: Model 1: $mse1; Model 2: $mse2")
          println(s"RMSE current batch: Model 1: $rmse1; Model 2: $rmse2")
          println("...\n")
        }
        ssc.start()
        ssc.awaitTermination()
      }
    }
    sbt run
    
    Enter number: 1
    展开全文
  • self-driving, 自驾驶汽车的机器学习模型 驱动自驾驶汽车的机器学习模型。 这里 repo 是一个 WIP,将定期更新。需要:KerasTensorFlow模型和任务基于深度学习的实时预测这里的具体任务是从安装的摄像头预测驱动速度...
  • (广义)线性模型机器学习发展几十年来理论和工具上最为完备的模型:不管是分类还是预测,线性模型都可以进行实时更新和预测;线性模型的解释性非常优秀,每个变量的回归系数都可以用于解释模型;最后,我们可以...
  • 从阿里的User Interest Center看模型线上实时serving方法这里是「王喆的机器学习笔记」的第二十九篇文章。最近写书的时候在总结一些深度学习模型线上serving的主流方法。之前的专栏文章也有所涉及(如何解决推荐系统...
  • 看《机器学习》遇到了不少的麻烦,发现里面的分析完全看不懂啊,然后别人就给推荐了李航的《统计学习方法》,说是讲的更浅显易懂一点,于是尝试一下从这里出发学习 监督学习 输入空间 输出空间 特征空间 监督...
  • Oryx的目标是帮助Hadoop用户搭建并部署能够实时查询的机器学习模型,例如垃圾邮件过滤和推荐引擎。随着数据的不断流入,Oryx还将支持自我更新。无论从建模还是部署,Oryx都可以随需扩展,Owen认为这是Oryx与Hadoop的...
  • 1.3 另一方面,机器学习模型的自动训练和实时性,可以大幅度提高预测信用评分准确性。 人工智能可以在毫无人工干预的情况下自动训练模型。消费金融客户特征随着时间变化,有非常明显的时间效应。因此,信贷模式必须...
  • Oryx的目标是帮助Hadoop用户搭建并部署能够实时查询的机器学习模型,例如垃圾邮件过滤和推荐引擎。随着数据的不断流入,Oryx还将支持自我更新。 无论从建模还是部署,Oryx都可以随需扩展 最近更新: ...
  • RTTHREAD 软件包目录 ai 包名 作者 license 备注 ...轻量级 ANN 库,可以训练,保存和导入模型 ...轻量级的神经网络框架, 模型一键转换, 让MCU也神经一把 ...开源神经网络模型 onnx 后端,支持几乎所有主流机器学习模型
  • 在线学习  传统的机器学习算法是批量模式的,... 与批量学习不同,在线学习假设训练数据持续到来,通常利用一个训练样本更新当前的模型,大大降低了学习算法的空间复杂度和时间复杂度,实时性强。  早期在线...
  • 接上篇文章第4章的4.3.3:电商推荐系统(上):推荐系统架构、数据模型、离线统计与机器学习推荐、历史热门商品、最近热门商品、商品平均得分统计推荐、基于隐语义模型的协同过滤推荐、用户商品推荐列表、商品相似度...
  • 该项目将Streamlit视为实验概念验证(PoC)机器学习应用程序的框架。 目前,仅Streamlit用于全部功能(后端和前端)。 但是,可以仅将Streamlit用作前端,并在FastAPI中实现后端(稍后将添加)。 该应用程序本身...
  • 本人在跟着导师做大数据分析,需要用到kafka,在Producer端,用Python(用的是kafka-python)将读取的数据经过训练好的机器学习模型计算之后,发送到指定的服务器(IP)的指定topic,因为需要将数据在web端做展示,...
  • 尽管Noggin可以在一般情况下使用,但它是围绕训练/测试和批处理/纪元范例设计的,用于训练机器学习模型。 Noggin的主要功能是: 按名称记录批次级别和时期级别的测量 嵌入Jupyter笔记本中,无缝更新测量的“实时...
  • 整个算法其实就是一个有监督的机器学习的过程。 数据整理 下载后的整个压缩数据包575M,其中包括的订单数据大约900万条。(其他Master表数据量很小,这里忽略不计) 使用MongoDB存储的话,大概使用2GB的空...
  • Streamlit是一个开放源代码的Python库,可轻松构建用于机器学习和数据科学的精美自定义Web应用程序。 要使用它,只需导入它,然后编写几行代码,然后使用运行脚本即可。Streamlit监视每次保存时的更改,并在编码时...
  • 金融领域越来越多的活动场景,如双十一、双十二、财富日、新春大促,具有活动...在线机器学习,能够根据线上反馈数据,实时快速地进行模型调整,使得模型及时反映线上的变化,提高线上预测的准确率,能够有效的解...
  • 它在模型实时更新、用户行为快速反馈等方向上拥有巨大的优势。自从 2018 年开始,它就被大量应用在了推荐系统中,在游戏、棋类、教育领域都有非常广泛的应用场景。那场经典人机围棋大战:Alpha Go 战胜李世石让强化...
  • 来自知乎王喆机器学习笔记《回顾Facebook经典CTR预估模型》,和推荐系统的局部更新(相反于全量更新)有关,《如何增强推荐系统模型更新的「实时性」?》 Facebook在2014发表的“Practical Lessons from Predicting...
  • NLP模型开发平台是以快速打造智能业务为核心目标,无需机器学习专业知识,模型创建-数据上传-数据标注(智能标注、数据扩充)-模型训练-模型发布-模型校验全流程可视化便捷操作,短时间内即可获得高精度NLP模型,真正...
  • AWS日前才更新了自然语言理解服务Comprehend,推出客制Entity辨识模型的功能,让不懂机器学习的开发人员,也能训练自家的Entity辨识模型,来自动萃取特定的字词。该公司的自动语音识别服务Transcribe近日也有新功能...

空空如也

空空如也

1 2 3 4 5 6
收藏数 114
精华内容 45
关键字:

机器学习实时更新模型