Scala for Machine Learning - 第4页

31楼

Lisrelchen(真实交易用户) 发表于 2016-4-20 09:45:29

package org.scalaml.supervised.hmm
import org.scalaml.core.Matrix
import org.scalaml.core.Types.ScalaMl._
import HMMConfig._
final protected class Alpha(lambda: HMMLambda, obs: Array[Int]) extends Pass(lambda, obs) {
val alpha: Double = {
alphaBeta = lambda.initAlpha(obs)
normalize(0)
sumUp
}
def logProb: Double = foldLeft(lambda.getT, (s, t) => s + Math.log(ct(t)), Math.log(alpha))
private def sumUp: Double = {
foreach(1, lambda.getT, t => {
updateAlpha(t) // Implements first equation of M3
normalize(t) // Normalized wit the sum of alpha(i), t 0 -> N-1
})
foldLeft(lambda.getN, (s, k) => s + alphaBeta(lambda.d_1, k))
}
private def updateAlpha(t: Int): Unit =
foreach(lambda.getN, i => {
val newValue = lambda.alpha(alphaBeta(t-1, i), i, obs(t))
alphaBeta += (t, i, lambda.alpha(alphaBeta(t-1, i), i, obs(t)))
})
}
object Alpha {
def apply(lambda: HMMLambda, obs: Array[Int]): Alpha = new Alpha(lambda,obs)
}
// -------------------------------- EOF -------------------------------------

复制代码

32楼

Lisrelchen(真实交易用户) 发表于 2016-4-20 09:48:45

package org.scalaml.supervised.hmm
import scala.util.{Try, Success, Failure}
import org.apache.log4j.Logger
import org.scalaml.util.DisplayUtils
final protected class BaumWelchEM(
config: HMMConfig,
obs: Array[Int],
numIters: Int,
eps: Double) extends HMMModel(HMMLambda(config), obs) {
import BaumWelchEM._
check(config, obs, numIters, eps)
private val logger = Logger.getLogger("BaumWelchEM")
val state = HMMState(lambda, numIters)
val maxLikelihood: Option[Double] = {
Try {
var likelihood = frwrdBckwrdLattice
// Apply the alpha / beta algorithm for each state
// until the likelihood value Alpha.alpha converges toward a maximum
Range(0, state.maxIters) find( _ => {
lambda.estimate(state, obs)
val _likelihood = frwrdBckwrdLattice
val diff = likelihood - _likelihood
likelihood = _likelihood
diff < eps
})
match {
case Some(index) => likelihood
case None => throw new IllegalStateException("BaumWelchEM.maxLikelihood failed")
}
}
match {
// If the maximum likelihood is computed, normalize the resulting Lambda model
case Success(likelihood) => {
state.lambda.normalize
Some(likelihood)
}
case Failure(e) => DisplayUtils.none("BaumWelchEM.maxLikelihood", logger, e)
}
}
/*
private def frwrdBckwrdLattice: Double = {
// Compute the forward pass given the sequence of observations obs
val _alpha = Alpha(lambda, obs)
// Compute the probabilities of a state given the
state.update(_alpha.getAlphaBeta, Beta(lambda, obs).getAlphaBeta, lambda.A, lambda.B, obs)
// Finally returns the likelihood
_alpha.alpha
}
}
object BaumWelchEM {
private val EPS = 1e-3
def apply(config: HMMConfig, labels: Array[Int], numIters: Int, eps: Double): BaumWelchEM =
new BaumWelchEM(config, labels, numIters,eps)
private val EPS_LIMITS = (1e-8, 0.1)
private val MAX_NUM_ITERS = 1024
private def check(config: HMMConfig, obs: Array[Int], numIters: Int, eps: Double): Unit = {
require( !obs.isEmpty, "BaumWelchEM.check Observations are undefined")
require(numIters > 1 && numIters < MAX_NUM_ITERS,
s"BaumWelchEM.check Maximum number of iterations $numIters is out of range")
require(eps > EPS_LIMITS._1 && eps < EPS_LIMITS._2,
s"BaumWelchEM.check Convergence criteria for HMM Baum_Welch $eps is out of range")
}
}
// ----------------------------- EOF --------------------------------

复制代码

33楼

Lisrelchen(真实交易用户) 发表于 2016-4-20 09:52:01

package org.scalaml.supervised.hmm
import scala.util.{Try, Success, Failure}
import org.apache.log4j.Logger
import org.scalaml.core.Matrix
import org.scalaml.util.DisplayUtils
import HMMConfig._
protected class Beta(lambda: HMMLambda, obs: Array[Int]) extends Pass(lambda, obs) {
private val logger = Logger.getLogger("Beta")
val complete = {
Try {
// Creates the matrix of probabilities of a state given the
// observations, and initialize the probability for the last observation
// (index T-1) as 1.0
alphaBeta = Matrix[Double](lambda.getT, lambda.getN)
alphaBeta += (lambda.d_1, 1.0)
// Normalize by computing (ct)
normalize(lambda.d_1)
// Compute the beta probabilites for all the observations.
sumUp
}
match {
case Success(t) => true
case Failure(e) => DisplayUtils.error("Beta.complete failed", logger, e); false
}
}
private def sumUp: Unit = {
// Update and normalize the beta probabilities for all
// the observations starting with index T-2.. befor normalization.
(lambda.getT-2 to 0 by -1).foreach( t =>{
updateBeta(t)
normalize(t)
})
}
private def updateBeta(t: Int): Unit =
foreach(lambda.getN, i =>
alphaBeta += (t, i, lambda.beta(alphaBeta(t+1, i), i, obs(t+1))))
}
object Beta {
def apply(lambda: HMMLambda, obs: Array[Int]): Beta = new Beta(lambda, obs)
}
// -------------------------------- EOF -------------------------------------

复制代码

34楼

Lisrelchen(真实交易用户) 发表于 2016-4-20 09:57:49

package org.scalaml.supervised.hmm
import org.scalaml.core.Types.ScalaMl._
import org.scalaml.core.Design.{PipeOperator, Model}
import org.scalaml.core.XTSeries
import org.scalaml.core.Matrix
import scala.util.{Try, Success, Failure}
import scala.annotation.implicitNotFound
import org.apache.log4j.Logger
import org.scalaml.util.DisplayUtils
import HMM._
object HMMForm extends Enumeration {
type HMMForm = Value
val EVALUATION, DECODING = Value
}
import HMMForm._
abstract class HMMModel(val lambda: HMMLambda, val obs: Array[Int]) extends Model {
import HMMModel._
check(obs)
}
object HMMModel {
private def check(obs: Array[Int]): Unit =
require(!obs.isEmpty, "HMMModel.check Cannot create a model with undefined observations")
}
protected class Pass(lambda: HMMLambda, obs: Array[Int]) extends HMMModel(lambda, obs) {
protected var alphaBeta: Matrix[Double] = _
protected val ct = Array.fill(lambda.getT)(0.0)
/**
* Compute and apply the normalization factor ct for the computation of Alpha
* [Formula M3] and Beta probabilities [Formula M7] for the observation at index t
* @param t Index of the observation.
*/
protected def normalize(t: Int): Unit = {
import HMMConfig._
require(t >= 0 && t < lambda.getT, s"HMMModel.normalize Incorrect observation index t= $t")
ct.update(t, foldLeft(lambda.getN, (s, n) => s + alphaBeta(t, n)))
alphaBeta /= (t, ct(t))
}
def getAlphaBeta: Matrix[Double] = alphaBeta
}
@implicitNotFound("HMM Conversion from DblVector to type T undefined")
final protected class HMM[@specialized T <% Array[Int]](
lambda: HMMLambda,
form: HMMForm,
maxIters: Int)
(implicit f: DblVector => T) extends PipeOperator[DblVector, HMMPredictor] {
check(maxIters)
private val logger = Logger.getLogger("HMM")
private[this] val state = HMMState(lambda, maxIters)
override def |> : PartialFunction[DblVector, HMMPredictor] = {
case obs: DblVector if( !obs.isEmpty) => {
Try {
form match {
case EVALUATION => evaluate(obs)
case DECODING => decode(obs)
}
} match {
case Success(prediction) => prediction
case Failure(e) =>
DisplayUtils.error("HMM.|> ", logger, e)
nullHMMPredictor
}
}
}
def decode(obs: T): HMMPredictor = (ViterbiPath(lambda, obs).maxDelta, state.QStar())
def evaluate(obs: T): HMMPredictor = (-Alpha(lambda, obs).logProb, obs)
final def getModel: HMMLambda = lambda
}
object HMM {
type HMMPredictor = (Double, Array[Int])
val nullHMMPredictor = (-1.0, Array.empty[Int])
def apply[T <% Array[Int]](
lambda: HMMLambda,
form: HMMForm,
maxIters: Int)
(implicit f: DblVector => T): HMM[T] = new HMM[T](lambda, form, maxIters)
def apply[T <% Array[Int]](
lambda: HMMLambda,
form: HMMForm)
(implicit f: DblVector => T): HMM[T] = new HMM[T](lambda, form, HMMState.DEFAULT_MAXITERS)
def apply[T <% Array[Int]](
config: HMMConfig,
obsIndx: Array[Int],
form: HMMForm,
maxIters: Int,
eps: Double)
(implicit f: DblVector => T): Option[HMM[T]] = {
val baumWelchEM = new BaumWelchEM(config, obsIndx, maxIters, eps)
baumWelchEM.maxLikelihood.map(_ => new HMM[T](baumWelchEM.lambda, form, maxIters))
}
val MAX_NUM_ITERS = 1024
private def check(maxIters: Int): Unit = {
require(maxIters > 1 && maxIters < MAX_NUM_ITERS,
s"HMM.check Maximum number of iterations to train a HMM $maxIters is out of bounds")
}
}
// ---------------------------------------- EOF ------------------------------------------------------------

复制代码

加关注串个门加好友发消息 0关注 463 粉丝巨擘 Nicolle 当前离线阅读权限 255 威望 16 级论坛币 12403139 个通用积分 1638.8018 学术水平 3305 点热心指数 3329 点信用等级 3095 点经验 476993 点帖子 23839 精华 91 在线时间 9878 小时注册时间 2005-4-23 最后登录 2022-3-6 雷达卡	35楼 Nicolle(真实交易用户) 发表于 2016-4-20 10:13:28 提示: 作者被禁止或删除内容自动屏蔽

	回复举报