id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c164800 | prefix string) error {
rt.Root = &DecisionTreeNode{}
return rt.Root.LoadWithPrefix(reader, prefix)
} | |
c164801 | FormatVersion: 1,
ClassifierName: "KNN",
ClassifierVersion: "1.0",
ClassifierMetadata: nil,
}
} | |
c164802 | } else {
return nil, WrapError(fmt.Errorf("Size mismatch, expected %d byte(s) for %s, got %d", len(ret), hdr.Name, hdr.Size))
}
}
if err != nil {
return nil, err
}
returnCandidate = ret
}
}
if returnCandidate == nil {
return nil, WrapError(fmt.Errorf("Not found (looking for %s)", name)... | |
c164803 | c.GetJSONForKey(c.Prefix(prefix, "METADATA"), &ret)
return ret, err
} | |
c164804 |
}
//
// Parse METADATA
//
var metadata ClassifierMetadataV1
ret := &ClassifierDeserializer{
f,
gzr,
tz,
&metadata,
}
metadata, err = ret.ReadMetadataAtPrefix("")
if err != nil {
return nil, fmt.Errorf("Error whilst reading METADATA: %s", err)
}
ret.Metadata = &metadata
// Check that we can und... | |
c164805 |
return c.tarReader.GetNamedFile(key)
} | |
c164806 | err != nil {
return err
}
return json.Unmarshal(b, v)
} | |
c164807 | return DeserializeInstancesFromTarReader(c.tarReader, key)
} | |
c164808 | != nil {
return 0, err
}
return UnpackBytesToU64(b), nil
} | |
c164809 | if err != nil {
return nil, WrapError(err)
}
attr, err := DeserializeAttribute(b)
if err != nil {
return nil, WrapError(err)
}
return attr, nil
} | |
c164810 | range ret {
attrKey := c.Prefix(key, fmt.Sprintf("%d", i))
ret[i], err = c.GetAttributeForKey(attrKey)
if err != nil {
return nil, DescribeError("Unable to read Attribute", err)
}
}
return ret, nil
} | |
c164811 | fmt.Errorf("Could not close gz: %s", err)
}
if err := c.fileWriter.Sync(); err != nil {
return fmt.Errorf("Could not close file writer: %s", err)
}
if err := c.fileWriter.Close(); err != nil {
return fmt.Errorf("Could not close file writer: %s", err)
}
return nil
} | |
c164812 | nil {
return fmt.Errorf("Could not write header for '%s': %s", key, err)
}
//
// Write data
//
if _, err := c.tarWriter.Write(b); err != nil {
return fmt.Errorf("Could not write data for '%s': %s", key, err)
}
c.tarWriter.Flush()
c.gzipWriter.Flush()
c.fileWriter.Sync()
return nil
} | |
c164813 | v uint64) error {
b := PackU64ToBytes(v)
return c.WriteBytesForKey(key, b)
} | |
c164814 | if err != nil {
return err
}
return c.WriteBytesForKey(key, b)
} | |
c164815 | != nil {
return WrapError(err)
}
return c.WriteBytesForKey(key, b)
} | |
c164816 | i, a := range attrs {
attrKey := c.Prefix(key, fmt.Sprintf("%d", i))
err = c.WriteAttributeForKey(attrKey, a)
if err != nil {
return DescribeError("Unable to write Attribute", err)
}
}
return nil
} | |
c164817 | SerializeInstancesToTarWriter(g, c.tarWriter, key, includeData)
} | |
c164818 | return c.WriteJSONForKey(c.Prefix(prefix, "METADATA"), &metadata)
} | |
c164819 | tw.WriteHeader(hdr); err != nil {
return nil, fmt.Errorf("Could not write CLS_MANIFEST header: %s", err)
}
if _, err := tw.Write([]byte(SerializationFormatVersion)); err != nil {
return nil, fmt.Errorf("Could not write CLS_MANIFEST contents: %s", err)
}
//
// Write the METADATA entry
//
err = ret.WriteMet... | |
c164820 | base.GeneratePredictionVector(what)
classAttr := ret.AllClassAttributes()[0]
classSpec, err := ret.GetAttribute(classAttr)
if err != nil {
panic(err)
}
for i, datum := range data {
result := p.score(datum)
if result > 0.0 {
ret.Set(classSpec, i, base.PackU64ToBytes(1))
} else {
ret.Set(classSpec, 1... | |
c164821 | p.Dual,
}
if p.ClassWeights != nil {
ret.ClassWeights = make([]float64, len(p.ClassWeights))
copy(ret.ClassWeights, p.ClassWeights)
}
return ret
} | |
c164822 | fmt.Errorf("Important: changed to primary form")
}
p.Dual = false
p.SolverType = L1R_L2LOSS_SVC
} else {
return fmt.Errorf("Must have L2 loss with L1 penalty")
}
} else {
return fmt.Errorf("Penalty must be \"l1\" or \"l2\"")
}
// Final validation
if p.SolverType == 0 {
return fmt.Errorf("Inval... | |
c164823 | NewParameter(p.SolverType, p.C, p.Eps)
} | |
c164824 | model
lr := LinearSVC{}
lr.param = params.convertToNativeFormat()
lr.Param = params
lr.model = nil
return &lr, nil
} | |
c164825 | writer.Close()
}()
fmt.Printf("writer: %v", writer)
return lr.SaveWithPrefix(writer, "")
} | |
c164826 | vectorY)
result := mat.Sum(subVector)
return result
} | |
c164827 |
"type": "binary",
"name": b.Name,
})
} | |
c164828 | panic(err)
}
ret := make([]byte, 1)
if f > 0 {
ret[0] = 1
}
return ret
} | |
c164829 | ok := other.(*BinaryAttribute); !ok {
return false
} else {
return a.Name == b.Name
}
} | |
c164830 |
if _, ok := other.(*BinaryAttribute); !ok {
return false
} else {
return true
}
} | |
c164831 | "attr": map[string]interface{}{
"values": Attr.values,
},
})
} | |
c164832 | range d["values"].([]interface{}) {
Attr.values = append(Attr.values, v.(string))
}
return nil
} | |
c164833 | := range Attr.values {
if val == userVal {
return PackU64ToBytes(uint64(idx))
}
}
return nil
} | |
c164834 | fmt.Sprintf("CategoricalAttribute(\"%s\", %s)", Attr.Name, Attr.values)
} | |
c164835 | len(Attr.values) {
return false
}
for i, a := range Attr.values {
if a != attribute.values[i] {
return false
}
}
return true
} | |
c164836 | *mat.Dense {
return pca.Fit(X).Transform(X)
} | |
c164837 |
}
if pca.Num_components < 0 {
panic("Number of components can't be less than zero")
}
return pca
} | |
c164838 | return compute(X, vTemp)
}
X = compute(X, vTemp)
result := mat.NewDense(num_samples, pca.Num_components, nil)
result.Copy(X)
return result
} | |
c164839 | for i := 0; i < cols; i++ {
sum := mat.Sum(matrix.ColView(i))
meanVector[i] = sum / float64(rows)
}
return mat.NewDense(1, cols, meanVector)
} | |
c164840 | = byte(val & (0xFF << 24) >> 24)
ret[2] = byte(val & (0xFF << 16) >> 16)
ret[1] = byte(val & (0xFF << 8) >> 8)
ret[0] = byte(val & (0xFF << 0) >> 0)
} | |
c164841 | []byte) {
PackU64ToBytesInline(math.Float64bits(val), ret)
} | |
c164842 | = byte(val & (0xFF << 24) >> 24)
ret[2] = byte(val & (0xFF << 16) >> 16)
ret[1] = byte(val & (0xFF << 8) >> 8)
ret[0] = byte(val & (0xFF << 0) >> 0)
return ret
} | |
c164843 | unsafe.Pointer(&val[0])
return *(*uint64)(pb)
} | |
c164844 | unsafe.Pointer(&val[0])
return *(*float64)(pb)
} | |
c164845 | float64 {
return float64(c[class][class])
} | |
c164846 | continue
}
ret += float64(c[k][class])
}
return ret
} | |
c164847 | for k := range c[class] {
if k == class {
continue
}
ret += float64(c[class][k])
}
return ret
} | |
c164848 | := range c[k] {
if l == class {
continue
}
ret += float64(c[k][l])
}
}
return ret
} | |
c164849 |
truePositives := GetTruePositives(class, c)
falsePositives := GetFalsePositives(class, c)
return truePositives / (truePositives + falsePositives)
} | |
c164850 |
truePositives := GetTruePositives(class, c)
falseNegatives := GetFalseNegatives(class, c)
return truePositives / (truePositives + falseNegatives)
} | |
c164851 |
falsePositives += GetFalsePositives(k, c)
}
return truePositives / (truePositives + falsePositives)
} | |
c164852 | precisionVals += GetPrecision(k, c)
}
return precisionVals / float64(len(c))
} | |
c164853 | falseNegatives += GetFalseNegatives(k, c)
}
return truePositives / (truePositives + falseNegatives)
} | |
c164854 | recallVals += GetRecall(k, c)
}
return recallVals / float64(len(c))
} | |
c164855 | c)
f1 := GetF1Score(k, c)
fmt.Fprintf(w, "%s\t%.0f\t%.0f\t%.0f\t%.4f\t%.4f\t%.4f\n", k, tp, fp, tn, prec, rec, f1)
}
w.Flush()
buffer.WriteString(fmt.Sprintf("Overall accuracy: %.4f\n", GetAccuracy(c)))
return buffer.String()
} | |
c164856 | }
fmt.Fprintf(w, "\t")
}
fmt.Fprintf(w, "\n")
for _, v := range ref {
fmt.Fprintf(w, "%s\t", v)
for _, v2 := range ref {
fmt.Fprintf(w, "%d\t", c[v][v2])
}
fmt.Fprintf(w, "\n")
}
w.Flush()
return buffer.String()
} | |
c164857 | '%s', Pond: %d/%d)", a.attr, a.pond, a.position)
} | |
c164858 | {
matched := false
if _, ok := a.(*FloatAttribute); !ok {
continue
}
for _, b := range classAttrs {
if a.Equals(b) {
matched = true
break
}
}
if !matched {
ret = append(ret, a)
}
}
return ret
} | |
c164859 |
return AttributeDifferenceReferences(allAttrs, classAttrs)
} | |
c164860 | if err != nil {
panic(fmt.Errorf("Error resolving Attribute %s: %s", a, err))
}
ret[i] = spec
}
sort.Sort(byPosition(ret))
return ret
} | |
c164861 | ResolveAttributes(f, attrs)
// Get the results
for i, a := range attrSpecs {
ret.Set(0, i, UnpackBytesToFloat(f.Get(a, r)))
}
// Return the result
return ret, nil
} | |
c164862 | := make([]*mat.Dense, rows)
// Resolve all attributes
attrSpecs := ResolveAttributes(f, attrs)
// Set the values in each return value
for i := 0; i < rows; i++ {
cur := mat.NewDense(1, len(attrs), nil)
for j, a := range attrSpecs {
cur.Set(0, j, UnpackBytesToFloat(f.Get(a, i)))
}
ret[i] = cur
}
retu... | |
c164863 |
break
} else if err != nil {
return 0, err
}
counter++
}
return counter, nil
} | |
c164864 | lineCount > 5 {
break
}
line := scanner.Text()
if len(line) == 0 {
continue
}
if line[0] == '@' {
continue
}
if line[0] == '%' {
continue
}
matches := rexp.FindAllString(line, -1)
for _, m := range matches {
p := strings.Split(m, ".")
if len(p) == 2 {
l := len(p[len(p)-1])
... | |
c164865 | ParseCSVSniffAttributeNamesFromReader(r, hasHeaders)
for i, attr := range attrs {
attr.SetName(names[i])
}
return attrs
} | |
c164866 | for i, h := range headers {
headers[i] = strings.TrimSpace(h)
}
return headers
}
for i := range headers {
headers[i] = fmt.Sprintf("%d", i)
}
return headers
} | |
c164867 | panic(err)
}
if matched {
attrs = append(attrs, NewFloatAttribute(""))
} else {
attrs = append(attrs, new(CategoricalAttribute))
}
}
// Estimate file precision
maxP, err := ParseCSVEstimateFilePrecisionFromReader(r)
if err != nil {
panic(err)
}
for _, a := range attrs {
if f, ok := a.(*Float... | |
c164868 | specs := make([]AttributeSpec, len(attrs))
// Allocate the Instances to return
instances = NewDenseInstances()
for i, a := range attrs {
spec := instances.AddAttribute(a)
specs[i] = spec
}
instances.Extend(rowCount)
err = ParseCSVBuildInstancesFromReader(r, attrs, hasHeaders, instances)
if err != nil {
r... | |
c164869 | b
} else if a.GetName() == b.GetName() {
attrs[i] = b
}
}
}
} | |
c164870 | = CopyDenseInstances(template, templateAttrs)
instances.Extend(rowCount)
err = ParseCSVBuildInstancesFromReader(r, attrs, hasHeaders, instances)
if err != nil {
return nil, err
}
for _, a := range template.AllClassAttributes() {
err = instances.AddClassAttribute(a)
if err != nil {
return nil, err
}
... | |
c164871 |
for a := range classAttrGroups {
agsToCreate[classAttrGroups[a]] = 8
combinedAgs[a] = classAttrGroups[a]
}
// Decide the sizes
for _, a := range attrs {
if ag, ok := combinedAgs[a.GetName()]; ok {
if _, ok := a.(*BinaryAttribute); ok {
agsToCreate[ag] = 0
} else {
agsToCreate[ag] = 8
}
}
... | |
c164872 | AbstractDiscretizeFilter{
make(map[base.Attribute]bool),
false,
d,
},
make(map[base.Attribute][]*FrequencyTableEntry),
significance,
2,
rows,
}
} | |
c164873 | := base.UnpackBytesToFloat(field)
for j, k := range table {
if k.Value < val {
dis = j
continue
}
break
}
return base.PackU64ToBytes(uint64(dis))
} | |
c164874 | return heapNode{}
}
return h.tree[0]
} | |
c164875 | h.tree[target-1].length {
largest = target * 2
}
if target*2 < len(h.tree) {
if h.tree[target*2].length > h.tree[largest-1].length {
largest = target*2 + 1
}
}
if largest == target {
break
}
h.tree[largest-1], h.tree[target-1] = h.tree[target-1], h.tree[largest-1]
target = largest
}
} | |
c164876 | if h.tree[(target/2)-1].length >= h.tree[target-1].length {
break
}
h.tree[target-1], h.tree[(target/2)-1] = h.tree[(target/2)-1], h.tree[target-1]
target /= 2
}
} | |
c164877 | p[i] = 1.0 / float64(p[i])
}
// Compute overall sum
sum := 0.0
for i := range p {
sum += p[i] * p[i]
}
return 1.0 - sum
} | |
c164878 | := range s[i] {
subtotal += float64(s[i][j])
}
cf := subtotal / float64(total)
cf *= computeGini(s[i])
sum += cf
}
return sum
} | |
c164879 | return fmt.Sprintf("DecisionTreeRule(%s <= %f)", d.SplitAttr.GetName(), d.SplitVal)
}
return fmt.Sprintf("DecisionTreeRule(%s)", d.SplitAttr.GetName())
} | |
c164880 |
}
serializer, err := base.CreateSerializedClassifierStub(filePath, metadata)
if err != nil {
return err
}
err = d.SaveWithPrefix(serializer, "")
if err != nil {
return err
}
return serializer.Close()
} | |
c164881 | nil {
return err
}
return d.LoadWithPrefix(reader, "")
} | |
c164882 | err != nil {
return err
}
err = json.Unmarshal(b, d)
if err != nil {
return err
}
a, err := reader.GetAttributeForKey(reader.Prefix(prefix, "treeClassAttr"))
if err != nil {
return err
}
d.ClassAttr = a
return nil
} | |
c164883 | _ := d.Predict(using)
baselineAccuracy := computeAccuracy(predictions, using)
// Speculatively remove the children and re-evaluate
tmpChildren := d.Children
d.Children = nil
predictions, _ = d.Predict(using)
newAccuracy := computeAccuracy(predictions, using)
// Keep the children removed if better, else resto... | |
c164884 | // If it's a numeric Attribute (e.g. FloatAttribute) check that
// the value of the current node is greater than the old one
classVal := base.UnpackBytesToFloat(what.Get(ats, rowNo))
if classVal > splitVal {
classVar = "1"
} else {
classVar = "0"
}
} else {
classVar = ats.... | |
c164885 |
base.BaseClassifier{},
nil,
prune,
new(InformationGainRuleGenerator),
}
} | |
c164886 | *ID3DecisionTree {
return &ID3DecisionTree{
base.BaseClassifier{},
nil,
prune,
rule,
}
} | |
c164887 | t.PruneSplit)
t.Root = InferID3Tree(trainData, t.Rule)
t.Root.Prune(testData)
} else {
t.Root = InferID3Tree(on, t.Rule)
}
return nil
} | |
c164888 | (base.FixedDataGrid, error) {
return t.Root.Predict(what)
} | |
c164889 | 0),
make([]base.FilteredAttribute, 0),
make(map[base.Attribute]bool),
make(map[base.Attribute]map[uint64]base.Attribute),
}
return ret
} | |
c164890 | else {
panic("Categorical value not defined!")
}
} else {
panic(fmt.Sprintf("Not a recognised Attribute %v", a))
}
} else if _, ok := a.(*base.BinaryAttribute); ok {
// Binary: just return the original value
ret = attrBytes
} else if _, ok := a.(*base.FloatAttribute); ok {
// Float: check for non... | |
c164891 |
f.Sync()
f.Close()
}()
return SerializeInstancesToCSVStream(inst, f)
} | |
c164892 |
curRow := make([]string, colCount)
inst.MapOverRows(specs, func(row [][]byte, rowNo int) (bool, error) {
for i, v := range row {
attr := allAttrs[i]
curRow[i] = attr.GetStringFromSysVal(v)
}
w.Write(curRow)
return true, nil
})
w.Flush()
return nil
} | |
c164893 |
tr := NewFunctionalTarReader(regenerateTarReader)
ret, deSerializeErr := DeserializeInstancesFromTarReader(tr, "")
if err = gzReader.Close(); err != nil {
return ret, fmt.Errorf("Error closing gzip stream: %s", err)
}
return ret, deSerializeErr
} | |
c164894 | tar: %s", err)
}
if err := gzWriter.Flush(); err != nil {
return fmt.Errorf("Could not flush gz: %s", err)
}
if err := gzWriter.Close(); err != nil {
return fmt.Errorf("Could not close gz: %s", err)
}
return serializeErr
} | |
c164895 | panic(err)
}
// Return me...
ret := &MultiLinearSVC{
parameters: params,
weights: weights,
}
ret.initializeOneVsAllModel()
return ret
} | |
c164896 | (base.FixedDataGrid, error) {
return m.m.Predict(from)
} | |
c164897 | }
return &ExpectationMaximization{n_comps: n_comps, eps: 0.001}, nil
} | |
c164898 | })
// Vector of predictions
preds := estimateLogProb(X, em.Params, em.n_comps)
clusterMap := make(map[int][]int)
for ix, pred := range vecToInts(preds) {
clusterMap[pred] = append(clusterMap[pred], ix)
}
return ClusterMap(clusterMap), nil
} | |
c164899 | := estimateLogProb(X, p, n_comps)
return y_new
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.