id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
164,700 | dexidp/dex | server/handlers.go | newHealthChecker | func (s *Server) newHealthChecker(ctx context.Context) http.Handler {
h := &healthChecker{s: s}
// Perform one health check synchronously so the returned handler returns
// valid data immediately.
h.runHealthCheck()
go func() {
for {
select {
case <-ctx.Done():
return
case <-time.After(time.Second * 15):
}
h.runHealthCheck()
}
}()
return h
} | go | func (s *Server) newHealthChecker(ctx context.Context) http.Handler {
h := &healthChecker{s: s}
// Perform one health check synchronously so the returned handler returns
// valid data immediately.
h.runHealthCheck()
go func() {
for {
select {
case <-ctx.Done():
return
case <-time.After(time.Second * 15):
}
h.runHealthCheck()
}
}()
return h
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"newHealthChecker",
"(",
"ctx",
"context",
".",
"Context",
")",
"http",
".",
"Handler",
"{",
"h",
":=",
"&",
"healthChecker",
"{",
"s",
":",
"s",
"}",
"\n\n",
"// Perform one health check synchronously so the returned handle... | // newHealthChecker returns the healthz handler. The handler runs until the
// provided context is canceled. | [
"newHealthChecker",
"returns",
"the",
"healthz",
"handler",
".",
"The",
"handler",
"runs",
"until",
"the",
"provided",
"context",
"is",
"canceled",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/server/handlers.go#L27-L45 |
164,701 | dexidp/dex | server/handlers.go | runHealthCheck | func (h *healthChecker) runHealthCheck() {
t := h.s.now()
err := checkStorageHealth(h.s.storage, h.s.now)
passed := h.s.now().Sub(t)
if err != nil {
h.s.logger.Errorf("Storage health check failed: %v", err)
}
// Make sure to only hold the mutex to access the fields, and not while
// we're querying the storage object.
h.mu.Lock()
h.err = err
h.passed = passed
h.mu.Unlock()
} | go | func (h *healthChecker) runHealthCheck() {
t := h.s.now()
err := checkStorageHealth(h.s.storage, h.s.now)
passed := h.s.now().Sub(t)
if err != nil {
h.s.logger.Errorf("Storage health check failed: %v", err)
}
// Make sure to only hold the mutex to access the fields, and not while
// we're querying the storage object.
h.mu.Lock()
h.err = err
h.passed = passed
h.mu.Unlock()
} | [
"func",
"(",
"h",
"*",
"healthChecker",
")",
"runHealthCheck",
"(",
")",
"{",
"t",
":=",
"h",
".",
"s",
".",
"now",
"(",
")",
"\n",
"err",
":=",
"checkStorageHealth",
"(",
"h",
".",
"s",
".",
"storage",
",",
"h",
".",
"s",
".",
"now",
")",
"\n"... | // runHealthCheck performs a single health check and makes the result available
// for any clients performing and HTTP request against the healthChecker. | [
"runHealthCheck",
"performs",
"a",
"single",
"health",
"check",
"and",
"makes",
"the",
"result",
"available",
"for",
"any",
"clients",
"performing",
"and",
"HTTP",
"request",
"against",
"the",
"healthChecker",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/server/handlers.go#L62-L76 |
164,702 | dexidp/dex | server/handlers.go | handleAuthorization | func (s *Server) handleAuthorization(w http.ResponseWriter, r *http.Request) {
authReq, err := s.parseAuthorizationRequest(r)
if err != nil {
s.logger.Errorf("Failed to parse authorization request: %v", err)
if handler, ok := err.Handle(); ok {
// client_id and redirect_uri checked out and we can redirect back to
// the client with the error.
handler.ServeHTTP(w, r)
return
}
// Otherwise render the error to the user.
//
// TODO(ericchiang): Should we just always render the error?
s.renderError(w, err.Status(), err.Error())
return
}
// TODO(ericchiang): Create this authorization request later in the login flow
// so users don't hit "not found" database errors if they wait at the login
// screen too long.
//
// See: https://github.com/dexidp/dex/issues/646
authReq.Expiry = s.now().Add(s.authRequestsValidFor)
if err := s.storage.CreateAuthRequest(authReq); err != nil {
s.logger.Errorf("Failed to create authorization request: %v", err)
s.renderError(w, http.StatusInternalServerError, "Failed to connect to the database.")
return
}
connectors, e := s.storage.ListConnectors()
if e != nil {
s.logger.Errorf("Failed to get list of connectors: %v", err)
s.renderError(w, http.StatusInternalServerError, "Failed to retrieve connector list.")
return
}
if len(connectors) == 1 {
for _, c := range connectors {
// TODO(ericchiang): Make this pass on r.URL.RawQuery and let something latter
// on create the auth request.
http.Redirect(w, r, s.absPath("/auth", c.ID)+"?req="+authReq.ID, http.StatusFound)
return
}
}
connectorInfos := make([]connectorInfo, len(connectors))
i := 0
for _, conn := range connectors {
connectorInfos[i] = connectorInfo{
ID: conn.ID,
Name: conn.Name,
// TODO(ericchiang): Make this pass on r.URL.RawQuery and let something latter
// on create the auth request.
URL: s.absPath("/auth", conn.ID) + "?req=" + authReq.ID,
}
i++
}
if err := s.templates.login(w, connectorInfos); err != nil {
s.logger.Errorf("Server template error: %v", err)
}
} | go | func (s *Server) handleAuthorization(w http.ResponseWriter, r *http.Request) {
authReq, err := s.parseAuthorizationRequest(r)
if err != nil {
s.logger.Errorf("Failed to parse authorization request: %v", err)
if handler, ok := err.Handle(); ok {
// client_id and redirect_uri checked out and we can redirect back to
// the client with the error.
handler.ServeHTTP(w, r)
return
}
// Otherwise render the error to the user.
//
// TODO(ericchiang): Should we just always render the error?
s.renderError(w, err.Status(), err.Error())
return
}
// TODO(ericchiang): Create this authorization request later in the login flow
// so users don't hit "not found" database errors if they wait at the login
// screen too long.
//
// See: https://github.com/dexidp/dex/issues/646
authReq.Expiry = s.now().Add(s.authRequestsValidFor)
if err := s.storage.CreateAuthRequest(authReq); err != nil {
s.logger.Errorf("Failed to create authorization request: %v", err)
s.renderError(w, http.StatusInternalServerError, "Failed to connect to the database.")
return
}
connectors, e := s.storage.ListConnectors()
if e != nil {
s.logger.Errorf("Failed to get list of connectors: %v", err)
s.renderError(w, http.StatusInternalServerError, "Failed to retrieve connector list.")
return
}
if len(connectors) == 1 {
for _, c := range connectors {
// TODO(ericchiang): Make this pass on r.URL.RawQuery and let something latter
// on create the auth request.
http.Redirect(w, r, s.absPath("/auth", c.ID)+"?req="+authReq.ID, http.StatusFound)
return
}
}
connectorInfos := make([]connectorInfo, len(connectors))
i := 0
for _, conn := range connectors {
connectorInfos[i] = connectorInfo{
ID: conn.ID,
Name: conn.Name,
// TODO(ericchiang): Make this pass on r.URL.RawQuery and let something latter
// on create the auth request.
URL: s.absPath("/auth", conn.ID) + "?req=" + authReq.ID,
}
i++
}
if err := s.templates.login(w, connectorInfos); err != nil {
s.logger.Errorf("Server template error: %v", err)
}
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"handleAuthorization",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"authReq",
",",
"err",
":=",
"s",
".",
"parseAuthorizationRequest",
"(",
"r",
")",
"\n",
"if",
"err",... | // handleAuthorization handles the OAuth2 auth endpoint. | [
"handleAuthorization",
"handles",
"the",
"OAuth2",
"auth",
"endpoint",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/server/handlers.go#L196-L258 |
164,703 | dexidp/dex | server/handlers.go | finalizeLogin | func (s *Server) finalizeLogin(identity connector.Identity, authReq storage.AuthRequest, conn connector.Connector) (string, error) {
claims := storage.Claims{
UserID: identity.UserID,
Username: identity.Username,
Email: identity.Email,
EmailVerified: identity.EmailVerified,
Groups: identity.Groups,
}
updater := func(a storage.AuthRequest) (storage.AuthRequest, error) {
a.LoggedIn = true
a.Claims = claims
a.ConnectorData = identity.ConnectorData
return a, nil
}
if err := s.storage.UpdateAuthRequest(authReq.ID, updater); err != nil {
return "", fmt.Errorf("failed to update auth request: %v", err)
}
email := claims.Email
if !claims.EmailVerified {
email = email + " (unverified)"
}
s.logger.Infof("login successful: connector %q, username=%q, email=%q, groups=%q",
authReq.ConnectorID, claims.Username, email, claims.Groups)
return path.Join(s.issuerURL.Path, "/approval") + "?req=" + authReq.ID, nil
} | go | func (s *Server) finalizeLogin(identity connector.Identity, authReq storage.AuthRequest, conn connector.Connector) (string, error) {
claims := storage.Claims{
UserID: identity.UserID,
Username: identity.Username,
Email: identity.Email,
EmailVerified: identity.EmailVerified,
Groups: identity.Groups,
}
updater := func(a storage.AuthRequest) (storage.AuthRequest, error) {
a.LoggedIn = true
a.Claims = claims
a.ConnectorData = identity.ConnectorData
return a, nil
}
if err := s.storage.UpdateAuthRequest(authReq.ID, updater); err != nil {
return "", fmt.Errorf("failed to update auth request: %v", err)
}
email := claims.Email
if !claims.EmailVerified {
email = email + " (unverified)"
}
s.logger.Infof("login successful: connector %q, username=%q, email=%q, groups=%q",
authReq.ConnectorID, claims.Username, email, claims.Groups)
return path.Join(s.issuerURL.Path, "/approval") + "?req=" + authReq.ID, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"finalizeLogin",
"(",
"identity",
"connector",
".",
"Identity",
",",
"authReq",
"storage",
".",
"AuthRequest",
",",
"conn",
"connector",
".",
"Connector",
")",
"(",
"string",
",",
"error",
")",
"{",
"claims",
":=",
"... | // finalizeLogin associates the user's identity with the current AuthRequest, then returns
// the approval page's path. | [
"finalizeLogin",
"associates",
"the",
"user",
"s",
"identity",
"with",
"the",
"current",
"AuthRequest",
"then",
"returns",
"the",
"approval",
"page",
"s",
"path",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/server/handlers.go#L461-L489 |
164,704 | dexidp/dex | server/handlers.go | usernamePrompt | func usernamePrompt(conn connector.PasswordConnector) string {
if attr := conn.Prompt(); attr != "" {
return attr
}
return "Username"
} | go | func usernamePrompt(conn connector.PasswordConnector) string {
if attr := conn.Prompt(); attr != "" {
return attr
}
return "Username"
} | [
"func",
"usernamePrompt",
"(",
"conn",
"connector",
".",
"PasswordConnector",
")",
"string",
"{",
"if",
"attr",
":=",
"conn",
".",
"Prompt",
"(",
")",
";",
"attr",
"!=",
"\"",
"\"",
"{",
"return",
"attr",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
... | // Check for username prompt override from connector. Defaults to "Username". | [
"Check",
"for",
"username",
"prompt",
"override",
"from",
"connector",
".",
"Defaults",
"to",
"Username",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/server/handlers.go#L1070-L1075 |
164,705 | dexidp/dex | server/server.go | NewServer | func NewServer(ctx context.Context, c Config) (*Server, error) {
return newServer(ctx, c, defaultRotationStrategy(
value(c.RotateKeysAfter, 6*time.Hour),
value(c.IDTokensValidFor, 24*time.Hour),
))
} | go | func NewServer(ctx context.Context, c Config) (*Server, error) {
return newServer(ctx, c, defaultRotationStrategy(
value(c.RotateKeysAfter, 6*time.Hour),
value(c.IDTokensValidFor, 24*time.Hour),
))
} | [
"func",
"NewServer",
"(",
"ctx",
"context",
".",
"Context",
",",
"c",
"Config",
")",
"(",
"*",
"Server",
",",
"error",
")",
"{",
"return",
"newServer",
"(",
"ctx",
",",
"c",
",",
"defaultRotationStrategy",
"(",
"value",
"(",
"c",
".",
"RotateKeysAfter",
... | // NewServer constructs a server from the provided config. | [
"NewServer",
"constructs",
"a",
"server",
"from",
"the",
"provided",
"config",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/server/server.go#L148-L153 |
164,706 | dexidp/dex | server/server.go | newKeyCacher | func newKeyCacher(s storage.Storage, now func() time.Time) storage.Storage {
if now == nil {
now = time.Now
}
return &keyCacher{Storage: s, now: now}
} | go | func newKeyCacher(s storage.Storage, now func() time.Time) storage.Storage {
if now == nil {
now = time.Now
}
return &keyCacher{Storage: s, now: now}
} | [
"func",
"newKeyCacher",
"(",
"s",
"storage",
".",
"Storage",
",",
"now",
"func",
"(",
")",
"time",
".",
"Time",
")",
"storage",
".",
"Storage",
"{",
"if",
"now",
"==",
"nil",
"{",
"now",
"=",
"time",
".",
"Now",
"\n",
"}",
"\n",
"return",
"&",
"k... | // newKeyCacher returns a storage which caches keys so long as the next | [
"newKeyCacher",
"returns",
"a",
"storage",
"which",
"caches",
"keys",
"so",
"long",
"as",
"the",
"next"
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/server/server.go#L382-L387 |
164,707 | dexidp/dex | server/server.go | openConnector | func openConnector(logger log.Logger, conn storage.Connector) (connector.Connector, error) {
var c connector.Connector
f, ok := ConnectorsConfig[conn.Type]
if !ok {
return c, fmt.Errorf("unknown connector type %q", conn.Type)
}
connConfig := f()
if len(conn.Config) != 0 {
data := []byte(string(conn.Config))
if err := json.Unmarshal(data, connConfig); err != nil {
return c, fmt.Errorf("parse connector config: %v", err)
}
}
c, err := connConfig.Open(conn.ID, logger)
if err != nil {
return c, fmt.Errorf("failed to create connector %s: %v", conn.ID, err)
}
return c, nil
} | go | func openConnector(logger log.Logger, conn storage.Connector) (connector.Connector, error) {
var c connector.Connector
f, ok := ConnectorsConfig[conn.Type]
if !ok {
return c, fmt.Errorf("unknown connector type %q", conn.Type)
}
connConfig := f()
if len(conn.Config) != 0 {
data := []byte(string(conn.Config))
if err := json.Unmarshal(data, connConfig); err != nil {
return c, fmt.Errorf("parse connector config: %v", err)
}
}
c, err := connConfig.Open(conn.ID, logger)
if err != nil {
return c, fmt.Errorf("failed to create connector %s: %v", conn.ID, err)
}
return c, nil
} | [
"func",
"openConnector",
"(",
"logger",
"log",
".",
"Logger",
",",
"conn",
"storage",
".",
"Connector",
")",
"(",
"connector",
".",
"Connector",
",",
"error",
")",
"{",
"var",
"c",
"connector",
".",
"Connector",
"\n\n",
"f",
",",
"ok",
":=",
"ConnectorsC... | // openConnector will parse the connector config and open the connector. | [
"openConnector",
"will",
"parse",
"the",
"connector",
"config",
"and",
"open",
"the",
"connector",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/server/server.go#L456-L478 |
164,708 | dexidp/dex | server/server.go | OpenConnector | func (s *Server) OpenConnector(conn storage.Connector) (Connector, error) {
var c connector.Connector
if conn.Type == LocalConnector {
c = newPasswordDB(s.storage)
} else {
var err error
c, err = openConnector(s.logger, conn)
if err != nil {
return Connector{}, fmt.Errorf("failed to open connector: %v", err)
}
}
connector := Connector{
ResourceVersion: conn.ResourceVersion,
Connector: c,
}
s.mu.Lock()
s.connectors[conn.ID] = connector
s.mu.Unlock()
return connector, nil
} | go | func (s *Server) OpenConnector(conn storage.Connector) (Connector, error) {
var c connector.Connector
if conn.Type == LocalConnector {
c = newPasswordDB(s.storage)
} else {
var err error
c, err = openConnector(s.logger, conn)
if err != nil {
return Connector{}, fmt.Errorf("failed to open connector: %v", err)
}
}
connector := Connector{
ResourceVersion: conn.ResourceVersion,
Connector: c,
}
s.mu.Lock()
s.connectors[conn.ID] = connector
s.mu.Unlock()
return connector, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"OpenConnector",
"(",
"conn",
"storage",
".",
"Connector",
")",
"(",
"Connector",
",",
"error",
")",
"{",
"var",
"c",
"connector",
".",
"Connector",
"\n\n",
"if",
"conn",
".",
"Type",
"==",
"LocalConnector",
"{",
"... | // OpenConnector updates server connector map with specified connector object. | [
"OpenConnector",
"updates",
"server",
"connector",
"map",
"with",
"specified",
"connector",
"object",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/server/server.go#L481-L503 |
164,709 | dexidp/dex | server/server.go | getConnector | func (s *Server) getConnector(id string) (Connector, error) {
storageConnector, err := s.storage.GetConnector(id)
if err != nil {
return Connector{}, fmt.Errorf("failed to get connector object from storage: %v", err)
}
var conn Connector
var ok bool
s.mu.Lock()
conn, ok = s.connectors[id]
s.mu.Unlock()
if !ok || storageConnector.ResourceVersion != conn.ResourceVersion {
// Connector object does not exist in server connectors map or
// has been updated in the storage. Need to get latest.
conn, err := s.OpenConnector(storageConnector)
if err != nil {
return Connector{}, fmt.Errorf("failed to open connector: %v", err)
}
return conn, nil
}
return conn, nil
} | go | func (s *Server) getConnector(id string) (Connector, error) {
storageConnector, err := s.storage.GetConnector(id)
if err != nil {
return Connector{}, fmt.Errorf("failed to get connector object from storage: %v", err)
}
var conn Connector
var ok bool
s.mu.Lock()
conn, ok = s.connectors[id]
s.mu.Unlock()
if !ok || storageConnector.ResourceVersion != conn.ResourceVersion {
// Connector object does not exist in server connectors map or
// has been updated in the storage. Need to get latest.
conn, err := s.OpenConnector(storageConnector)
if err != nil {
return Connector{}, fmt.Errorf("failed to open connector: %v", err)
}
return conn, nil
}
return conn, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"getConnector",
"(",
"id",
"string",
")",
"(",
"Connector",
",",
"error",
")",
"{",
"storageConnector",
",",
"err",
":=",
"s",
".",
"storage",
".",
"GetConnector",
"(",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // getConnector retrieves the connector object with the given id from the storage
// and updates the connector list for server if necessary. | [
"getConnector",
"retrieves",
"the",
"connector",
"object",
"with",
"the",
"given",
"id",
"from",
"the",
"storage",
"and",
"updates",
"the",
"connector",
"list",
"for",
"server",
"if",
"necessary",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/server/server.go#L507-L530 |
164,710 | dexidp/dex | connector/keystone/keystone.go | Open | func (c *Config) Open(id string, logger log.Logger) (connector.Connector, error) {
return &conn{
c.Domain,
c.Host,
c.AdminUsername,
c.AdminPassword,
logger}, nil
} | go | func (c *Config) Open(id string, logger log.Logger) (connector.Connector, error) {
return &conn{
c.Domain,
c.Host,
c.AdminUsername,
c.AdminPassword,
logger}, nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Open",
"(",
"id",
"string",
",",
"logger",
"log",
".",
"Logger",
")",
"(",
"connector",
".",
"Connector",
",",
"error",
")",
"{",
"return",
"&",
"conn",
"{",
"c",
".",
"Domain",
",",
"c",
".",
"Host",
",",
... | // Open returns an authentication strategy using Keystone. | [
"Open",
"returns",
"an",
"authentication",
"strategy",
"using",
"Keystone",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/connector/keystone/keystone.go#L104-L111 |
164,711 | dexidp/dex | connector/github/github.go | Open | func (c *Config) Open(id string, logger log.Logger) (connector.Connector, error) {
if c.Org != "" {
// Return error if both 'org' and 'orgs' fields are used.
if len(c.Orgs) > 0 {
return nil, errors.New("github: cannot use both 'org' and 'orgs' fields simultaneously")
}
logger.Warn("github: legacy field 'org' being used. Switch to the newer 'orgs' field structure")
}
g := githubConnector{
redirectURI: c.RedirectURI,
org: c.Org,
orgs: c.Orgs,
clientID: c.ClientID,
clientSecret: c.ClientSecret,
apiURL: apiURL,
logger: logger,
useLoginAsID: c.UseLoginAsID,
}
if c.HostName != "" {
// ensure this is a hostname and not a URL or path.
if strings.Contains(c.HostName, "/") {
return nil, errors.New("invalid hostname: hostname cannot contain `/`")
}
g.hostName = c.HostName
g.apiURL = "https://" + c.HostName + "/api/v3"
}
if c.RootCA != "" {
if c.HostName == "" {
return nil, errors.New("invalid connector config: Host name field required for a root certificate file")
}
g.rootCA = c.RootCA
var err error
if g.httpClient, err = newHTTPClient(g.rootCA); err != nil {
return nil, fmt.Errorf("failed to create HTTP client: %v", err)
}
}
g.loadAllGroups = c.LoadAllGroups
switch c.TeamNameField {
case "name", "slug", "both", "":
g.teamNameField = c.TeamNameField
default:
return nil, fmt.Errorf("invalid connector config: unsupported team name field value `%s`", c.TeamNameField)
}
return &g, nil
} | go | func (c *Config) Open(id string, logger log.Logger) (connector.Connector, error) {
if c.Org != "" {
// Return error if both 'org' and 'orgs' fields are used.
if len(c.Orgs) > 0 {
return nil, errors.New("github: cannot use both 'org' and 'orgs' fields simultaneously")
}
logger.Warn("github: legacy field 'org' being used. Switch to the newer 'orgs' field structure")
}
g := githubConnector{
redirectURI: c.RedirectURI,
org: c.Org,
orgs: c.Orgs,
clientID: c.ClientID,
clientSecret: c.ClientSecret,
apiURL: apiURL,
logger: logger,
useLoginAsID: c.UseLoginAsID,
}
if c.HostName != "" {
// ensure this is a hostname and not a URL or path.
if strings.Contains(c.HostName, "/") {
return nil, errors.New("invalid hostname: hostname cannot contain `/`")
}
g.hostName = c.HostName
g.apiURL = "https://" + c.HostName + "/api/v3"
}
if c.RootCA != "" {
if c.HostName == "" {
return nil, errors.New("invalid connector config: Host name field required for a root certificate file")
}
g.rootCA = c.RootCA
var err error
if g.httpClient, err = newHTTPClient(g.rootCA); err != nil {
return nil, fmt.Errorf("failed to create HTTP client: %v", err)
}
}
g.loadAllGroups = c.LoadAllGroups
switch c.TeamNameField {
case "name", "slug", "both", "":
g.teamNameField = c.TeamNameField
default:
return nil, fmt.Errorf("invalid connector config: unsupported team name field value `%s`", c.TeamNameField)
}
return &g, nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Open",
"(",
"id",
"string",
",",
"logger",
"log",
".",
"Logger",
")",
"(",
"connector",
".",
"Connector",
",",
"error",
")",
"{",
"if",
"c",
".",
"Org",
"!=",
"\"",
"\"",
"{",
"// Return error if both 'org' and 'o... | // Open returns a strategy for logging in through GitHub. | [
"Open",
"returns",
"a",
"strategy",
"for",
"logging",
"in",
"through",
"GitHub",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/connector/github/github.go#L68-L121 |
164,712 | dexidp/dex | connector/github/github.go | newHTTPClient | func newHTTPClient(rootCA string) (*http.Client, error) {
tlsConfig := tls.Config{RootCAs: x509.NewCertPool()}
rootCABytes, err := ioutil.ReadFile(rootCA)
if err != nil {
return nil, fmt.Errorf("failed to read root-ca: %v", err)
}
if !tlsConfig.RootCAs.AppendCertsFromPEM(rootCABytes) {
return nil, fmt.Errorf("no certs found in root CA file %q", rootCA)
}
return &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tlsConfig,
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
},
}, nil
} | go | func newHTTPClient(rootCA string) (*http.Client, error) {
tlsConfig := tls.Config{RootCAs: x509.NewCertPool()}
rootCABytes, err := ioutil.ReadFile(rootCA)
if err != nil {
return nil, fmt.Errorf("failed to read root-ca: %v", err)
}
if !tlsConfig.RootCAs.AppendCertsFromPEM(rootCABytes) {
return nil, fmt.Errorf("no certs found in root CA file %q", rootCA)
}
return &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tlsConfig,
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
},
}, nil
} | [
"func",
"newHTTPClient",
"(",
"rootCA",
"string",
")",
"(",
"*",
"http",
".",
"Client",
",",
"error",
")",
"{",
"tlsConfig",
":=",
"tls",
".",
"Config",
"{",
"RootCAs",
":",
"x509",
".",
"NewCertPool",
"(",
")",
"}",
"\n",
"rootCABytes",
",",
"err",
... | // newHTTPClient returns a new HTTP client that trusts the custom delcared rootCA cert. | [
"newHTTPClient",
"returns",
"a",
"new",
"HTTP",
"client",
"that",
"trusts",
"the",
"custom",
"delcared",
"rootCA",
"cert",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/connector/github/github.go#L209-L234 |
164,713 | dexidp/dex | connector/github/github.go | getGroups | func (c *githubConnector) getGroups(ctx context.Context, client *http.Client, groupScope bool, userLogin string) ([]string, error) {
if len(c.orgs) > 0 {
return c.groupsForOrgs(ctx, client, userLogin)
} else if c.org != "" {
return c.teamsForOrg(ctx, client, c.org)
} else if groupScope && c.loadAllGroups {
return c.userGroups(ctx, client)
}
return nil, nil
} | go | func (c *githubConnector) getGroups(ctx context.Context, client *http.Client, groupScope bool, userLogin string) ([]string, error) {
if len(c.orgs) > 0 {
return c.groupsForOrgs(ctx, client, userLogin)
} else if c.org != "" {
return c.teamsForOrg(ctx, client, c.org)
} else if groupScope && c.loadAllGroups {
return c.userGroups(ctx, client)
}
return nil, nil
} | [
"func",
"(",
"c",
"*",
"githubConnector",
")",
"getGroups",
"(",
"ctx",
"context",
".",
"Context",
",",
"client",
"*",
"http",
".",
"Client",
",",
"groupScope",
"bool",
",",
"userLogin",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
... | // getGroups retrieves GitHub orgs and teams a user is in, if any. | [
"getGroups",
"retrieves",
"GitHub",
"orgs",
"and",
"teams",
"a",
"user",
"is",
"in",
"if",
"any",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/connector/github/github.go#L334-L343 |
164,714 | dexidp/dex | connector/github/github.go | formatTeamName | func formatTeamName(org string, team string) string {
return fmt.Sprintf("%s:%s", org, team)
} | go | func formatTeamName(org string, team string) string {
return fmt.Sprintf("%s:%s", org, team)
} | [
"func",
"formatTeamName",
"(",
"org",
"string",
",",
"team",
"string",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"org",
",",
"team",
")",
"\n",
"}"
] | // formatTeamName returns unique team name.
// Orgs might have the same team names. To make team name unique it should be prefixed with the org name. | [
"formatTeamName",
"returns",
"unique",
"team",
"name",
".",
"Orgs",
"might",
"have",
"the",
"same",
"team",
"names",
".",
"To",
"make",
"team",
"name",
"unique",
"it",
"should",
"be",
"prefixed",
"with",
"the",
"org",
"name",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/connector/github/github.go#L347-L349 |
164,715 | dexidp/dex | connector/github/github.go | userOrgs | func (c *githubConnector) userOrgs(ctx context.Context, client *http.Client) ([]string, error) {
groups := make([]string, 0)
apiURL := c.apiURL + "/user/orgs"
for {
// https://developer.github.com/v3/orgs/#list-your-organizations
var (
orgs []org
err error
)
if apiURL, err = get(ctx, client, apiURL, &orgs); err != nil {
return nil, fmt.Errorf("github: get orgs: %v", err)
}
for _, o := range orgs {
groups = append(groups, o.Login)
}
if apiURL == "" {
break
}
}
return groups, nil
} | go | func (c *githubConnector) userOrgs(ctx context.Context, client *http.Client) ([]string, error) {
groups := make([]string, 0)
apiURL := c.apiURL + "/user/orgs"
for {
// https://developer.github.com/v3/orgs/#list-your-organizations
var (
orgs []org
err error
)
if apiURL, err = get(ctx, client, apiURL, &orgs); err != nil {
return nil, fmt.Errorf("github: get orgs: %v", err)
}
for _, o := range orgs {
groups = append(groups, o.Login)
}
if apiURL == "" {
break
}
}
return groups, nil
} | [
"func",
"(",
"c",
"*",
"githubConnector",
")",
"userOrgs",
"(",
"ctx",
"context",
".",
"Context",
",",
"client",
"*",
"http",
".",
"Client",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"groups",
":=",
"make",
"(",
"[",
"]",
"string",
",",... | // userOrgs retrieves list of current user orgs | [
"userOrgs",
"retrieves",
"list",
"of",
"current",
"user",
"orgs"
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/connector/github/github.go#L417-L440 |
164,716 | dexidp/dex | connector/github/github.go | userOrgTeams | func (c *githubConnector) userOrgTeams(ctx context.Context, client *http.Client) (map[string][]string, error) {
groups := make(map[string][]string, 0)
apiURL := c.apiURL + "/user/teams"
for {
// https://developer.github.com/v3/orgs/teams/#list-user-teams
var (
teams []team
err error
)
if apiURL, err = get(ctx, client, apiURL, &teams); err != nil {
return nil, fmt.Errorf("github: get teams: %v", err)
}
for _, t := range teams {
groups[t.Org.Login] = append(groups[t.Org.Login], c.teamGroupClaims(t)...)
}
if apiURL == "" {
break
}
}
return groups, nil
} | go | func (c *githubConnector) userOrgTeams(ctx context.Context, client *http.Client) (map[string][]string, error) {
groups := make(map[string][]string, 0)
apiURL := c.apiURL + "/user/teams"
for {
// https://developer.github.com/v3/orgs/teams/#list-user-teams
var (
teams []team
err error
)
if apiURL, err = get(ctx, client, apiURL, &teams); err != nil {
return nil, fmt.Errorf("github: get teams: %v", err)
}
for _, t := range teams {
groups[t.Org.Login] = append(groups[t.Org.Login], c.teamGroupClaims(t)...)
}
if apiURL == "" {
break
}
}
return groups, nil
} | [
"func",
"(",
"c",
"*",
"githubConnector",
")",
"userOrgTeams",
"(",
"ctx",
"context",
".",
"Context",
",",
"client",
"*",
"http",
".",
"Client",
")",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
",",
"error",
")",
"{",
"groups",
":=",
"make",
... | // userOrgTeams retrieves teams which current user belongs to.
// Method returns a map where key is an org name and value list of teams under the org. | [
"userOrgTeams",
"retrieves",
"teams",
"which",
"current",
"user",
"belongs",
"to",
".",
"Method",
"returns",
"a",
"map",
"where",
"key",
"is",
"an",
"org",
"name",
"and",
"value",
"list",
"of",
"teams",
"under",
"the",
"org",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/connector/github/github.go#L444-L467 |
164,717 | dexidp/dex | connector/github/github.go | filterTeams | func filterTeams(userTeams, configTeams []string) (teams []string) {
teamFilter := make(map[string]struct{})
for _, team := range configTeams {
if _, ok := teamFilter[team]; !ok {
teamFilter[team] = struct{}{}
}
}
for _, team := range userTeams {
if _, ok := teamFilter[team]; ok {
teams = append(teams, team)
}
}
return
} | go | func filterTeams(userTeams, configTeams []string) (teams []string) {
teamFilter := make(map[string]struct{})
for _, team := range configTeams {
if _, ok := teamFilter[team]; !ok {
teamFilter[team] = struct{}{}
}
}
for _, team := range userTeams {
if _, ok := teamFilter[team]; ok {
teams = append(teams, team)
}
}
return
} | [
"func",
"filterTeams",
"(",
"userTeams",
",",
"configTeams",
"[",
"]",
"string",
")",
"(",
"teams",
"[",
"]",
"string",
")",
"{",
"teamFilter",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
"\n",
"for",
"_",
",",
"team",
":... | // Filter the users' team memberships by 'teams' from config. | [
"Filter",
"the",
"users",
"team",
"memberships",
"by",
"teams",
"from",
"config",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/connector/github/github.go#L470-L483 |
164,718 | dexidp/dex | connector/ldap/ldap.go | Open | func (c *Config) Open(id string, logger log.Logger) (connector.Connector, error) {
conn, err := c.OpenConnector(logger)
if err != nil {
return nil, err
}
return connector.Connector(conn), nil
} | go | func (c *Config) Open(id string, logger log.Logger) (connector.Connector, error) {
conn, err := c.OpenConnector(logger)
if err != nil {
return nil, err
}
return connector.Connector(conn), nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Open",
"(",
"id",
"string",
",",
"logger",
"log",
".",
"Logger",
")",
"(",
"connector",
".",
"Connector",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"c",
".",
"OpenConnector",
"(",
"logger",
")",
"\n",
... | // Open returns an authentication strategy using LDAP. | [
"Open",
"returns",
"an",
"authentication",
"strategy",
"using",
"LDAP",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/connector/ldap/ldap.go#L167-L173 |
164,719 | dexidp/dex | connector/ldap/ldap.go | OpenConnector | func (c *Config) OpenConnector(logger log.Logger) (interface {
connector.Connector
connector.PasswordConnector
connector.RefreshConnector
}, error) {
return c.openConnector(logger)
} | go | func (c *Config) OpenConnector(logger log.Logger) (interface {
connector.Connector
connector.PasswordConnector
connector.RefreshConnector
}, error) {
return c.openConnector(logger)
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"OpenConnector",
"(",
"logger",
"log",
".",
"Logger",
")",
"(",
"interface",
"{",
"connector",
".",
"Connector",
"\n",
"connector",
".",
"PasswordConnector",
"\n",
"connector",
".",
"RefreshConnector",
"\n",
"}",
",",
... | // OpenConnector is the same as Open but returns a type with all implemented connector interfaces. | [
"OpenConnector",
"is",
"the",
"same",
"as",
"Open",
"but",
"returns",
"a",
"type",
"with",
"all",
"implemented",
"connector",
"interfaces",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/connector/ldap/ldap.go#L181-L187 |
164,720 | dexidp/dex | connector/ldap/ldap.go | do | func (c *ldapConnector) do(ctx context.Context, f func(c *ldap.Conn) error) error {
// TODO(ericchiang): support context here
var (
conn *ldap.Conn
err error
)
switch {
case c.InsecureNoSSL:
conn, err = ldap.Dial("tcp", c.Host)
case c.StartTLS:
conn, err = ldap.Dial("tcp", c.Host)
if err != nil {
return fmt.Errorf("failed to connect: %v", err)
}
if err := conn.StartTLS(c.tlsConfig); err != nil {
return fmt.Errorf("start TLS failed: %v", err)
}
default:
conn, err = ldap.DialTLS("tcp", c.Host, c.tlsConfig)
}
if err != nil {
return fmt.Errorf("failed to connect: %v", err)
}
defer conn.Close()
// If bindDN and bindPW are empty this will default to an anonymous bind.
if err := conn.Bind(c.BindDN, c.BindPW); err != nil {
if c.BindDN == "" && c.BindPW == "" {
return fmt.Errorf("ldap: initial anonymous bind failed: %v", err)
}
return fmt.Errorf("ldap: initial bind for user %q failed: %v", c.BindDN, err)
}
return f(conn)
} | go | func (c *ldapConnector) do(ctx context.Context, f func(c *ldap.Conn) error) error {
// TODO(ericchiang): support context here
var (
conn *ldap.Conn
err error
)
switch {
case c.InsecureNoSSL:
conn, err = ldap.Dial("tcp", c.Host)
case c.StartTLS:
conn, err = ldap.Dial("tcp", c.Host)
if err != nil {
return fmt.Errorf("failed to connect: %v", err)
}
if err := conn.StartTLS(c.tlsConfig); err != nil {
return fmt.Errorf("start TLS failed: %v", err)
}
default:
conn, err = ldap.DialTLS("tcp", c.Host, c.tlsConfig)
}
if err != nil {
return fmt.Errorf("failed to connect: %v", err)
}
defer conn.Close()
// If bindDN and bindPW are empty this will default to an anonymous bind.
if err := conn.Bind(c.BindDN, c.BindPW); err != nil {
if c.BindDN == "" && c.BindPW == "" {
return fmt.Errorf("ldap: initial anonymous bind failed: %v", err)
}
return fmt.Errorf("ldap: initial bind for user %q failed: %v", c.BindDN, err)
}
return f(conn)
} | [
"func",
"(",
"c",
"*",
"ldapConnector",
")",
"do",
"(",
"ctx",
"context",
".",
"Context",
",",
"f",
"func",
"(",
"c",
"*",
"ldap",
".",
"Conn",
")",
"error",
")",
"error",
"{",
"// TODO(ericchiang): support context here",
"var",
"(",
"conn",
"*",
"ldap",... | // do initializes a connection to the LDAP directory and passes it to the
// provided function. It then performs appropriate teardown or reuse before
// returning. | [
"do",
"initializes",
"a",
"connection",
"to",
"the",
"LDAP",
"directory",
"and",
"passes",
"it",
"to",
"the",
"provided",
"function",
".",
"It",
"then",
"performs",
"appropriate",
"teardown",
"or",
"reuse",
"before",
"returning",
"."
] | 60f47c4228b7719889eee4ca6c4c6cc60834d910 | https://github.com/dexidp/dex/blob/60f47c4228b7719889eee4ca6c4c6cc60834d910/connector/ldap/ldap.go#L272-L306 |
164,721 | sjwhitworth/golearn | evaluation/cross_fold.go | GetCrossValidatedMetric | func GetCrossValidatedMetric(in []ConfusionMatrix, metric func(ConfusionMatrix) float64) (mean, variance float64) {
scores := make([]float64, len(in))
for i, c := range in {
scores[i] = metric(c)
}
// Compute mean, variance
sum := 0.0
for _, s := range scores {
sum += s
}
sum /= float64(len(scores))
mean = sum
sum = 0.0
for _, s := range scores {
sum += (s - mean) * (s - mean)
}
sum /= float64(len(scores))
variance = sum
return mean, variance
} | go | func GetCrossValidatedMetric(in []ConfusionMatrix, metric func(ConfusionMatrix) float64) (mean, variance float64) {
scores := make([]float64, len(in))
for i, c := range in {
scores[i] = metric(c)
}
// Compute mean, variance
sum := 0.0
for _, s := range scores {
sum += s
}
sum /= float64(len(scores))
mean = sum
sum = 0.0
for _, s := range scores {
sum += (s - mean) * (s - mean)
}
sum /= float64(len(scores))
variance = sum
return mean, variance
} | [
"func",
"GetCrossValidatedMetric",
"(",
"in",
"[",
"]",
"ConfusionMatrix",
",",
"metric",
"func",
"(",
"ConfusionMatrix",
")",
"float64",
")",
"(",
"mean",
",",
"variance",
"float64",
")",
"{",
"scores",
":=",
"make",
"(",
"[",
"]",
"float64",
",",
"len",
... | // GetCrossValidatedMetric returns the mean and variance of the confusion-matrix-derived
// metric across all folds. | [
"GetCrossValidatedMetric",
"returns",
"the",
"mean",
"and",
"variance",
"of",
"the",
"confusion",
"-",
"matrix",
"-",
"derived",
"metric",
"across",
"all",
"folds",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/evaluation/cross_fold.go#L10-L30 |
164,722 | sjwhitworth/golearn | evaluation/cross_fold.go | GenerateCrossFoldValidationConfusionMatrices | func GenerateCrossFoldValidationConfusionMatrices(data base.FixedDataGrid, cls base.Classifier, folds int) ([]ConfusionMatrix, error) {
_, rows := data.Size()
// Assign each row to a fold
foldMap := make([]int, rows)
inverseFoldMap := make(map[int][]int)
for i := 0; i < rows; i++ {
fold := rand.Intn(folds)
foldMap[i] = fold
if _, ok := inverseFoldMap[fold]; !ok {
inverseFoldMap[fold] = make([]int, 0)
}
inverseFoldMap[fold] = append(inverseFoldMap[fold], i)
}
ret := make([]ConfusionMatrix, folds)
// Create training/test views for each fold
for i := 0; i < folds; i++ {
// Fold i is for testing
testData := base.NewInstancesViewFromVisible(data, inverseFoldMap[i], data.AllAttributes())
otherRows := make([]int, 0)
for j := 0; j < folds; j++ {
if i == j {
continue
}
otherRows = append(otherRows, inverseFoldMap[j]...)
}
trainData := base.NewInstancesViewFromVisible(data, otherRows, data.AllAttributes())
// Train
err := cls.Fit(trainData)
if err != nil {
return nil, err
}
// Predict
pred, err := cls.Predict(testData)
if err != nil {
return nil, err
}
// Evaluate
cf, err := GetConfusionMatrix(testData, pred)
if err != nil {
return nil, err
}
ret[i] = cf
}
return ret, nil
} | go | func GenerateCrossFoldValidationConfusionMatrices(data base.FixedDataGrid, cls base.Classifier, folds int) ([]ConfusionMatrix, error) {
_, rows := data.Size()
// Assign each row to a fold
foldMap := make([]int, rows)
inverseFoldMap := make(map[int][]int)
for i := 0; i < rows; i++ {
fold := rand.Intn(folds)
foldMap[i] = fold
if _, ok := inverseFoldMap[fold]; !ok {
inverseFoldMap[fold] = make([]int, 0)
}
inverseFoldMap[fold] = append(inverseFoldMap[fold], i)
}
ret := make([]ConfusionMatrix, folds)
// Create training/test views for each fold
for i := 0; i < folds; i++ {
// Fold i is for testing
testData := base.NewInstancesViewFromVisible(data, inverseFoldMap[i], data.AllAttributes())
otherRows := make([]int, 0)
for j := 0; j < folds; j++ {
if i == j {
continue
}
otherRows = append(otherRows, inverseFoldMap[j]...)
}
trainData := base.NewInstancesViewFromVisible(data, otherRows, data.AllAttributes())
// Train
err := cls.Fit(trainData)
if err != nil {
return nil, err
}
// Predict
pred, err := cls.Predict(testData)
if err != nil {
return nil, err
}
// Evaluate
cf, err := GetConfusionMatrix(testData, pred)
if err != nil {
return nil, err
}
ret[i] = cf
}
return ret, nil
} | [
"func",
"GenerateCrossFoldValidationConfusionMatrices",
"(",
"data",
"base",
".",
"FixedDataGrid",
",",
"cls",
"base",
".",
"Classifier",
",",
"folds",
"int",
")",
"(",
"[",
"]",
"ConfusionMatrix",
",",
"error",
")",
"{",
"_",
",",
"rows",
":=",
"data",
".",... | // GenerateCrossFoldValidationConfusionMatrices divides the data into a number of folds
// then trains and evaluates the classifier on each fold, producing a new ConfusionMatrix. | [
"GenerateCrossFoldValidationConfusionMatrices",
"divides",
"the",
"data",
"into",
"a",
"number",
"of",
"folds",
"then",
"trains",
"and",
"evaluates",
"the",
"classifier",
"on",
"each",
"fold",
"producing",
"a",
"new",
"ConfusionMatrix",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/evaluation/cross_fold.go#L34-L81 |
164,723 | sjwhitworth/golearn | base/bag.go | Attributes | func (b *BinaryAttributeGroup) Attributes() []Attribute {
ret := make([]Attribute, len(b.attributes))
for i, a := range b.attributes {
ret[i] = a
}
return ret
} | go | func (b *BinaryAttributeGroup) Attributes() []Attribute {
ret := make([]Attribute, len(b.attributes))
for i, a := range b.attributes {
ret[i] = a
}
return ret
} | [
"func",
"(",
"b",
"*",
"BinaryAttributeGroup",
")",
"Attributes",
"(",
")",
"[",
"]",
"Attribute",
"{",
"ret",
":=",
"make",
"(",
"[",
"]",
"Attribute",
",",
"len",
"(",
"b",
".",
"attributes",
")",
")",
"\n",
"for",
"i",
",",
"a",
":=",
"range",
... | // Attributes returns a slice of Attributes in this BinaryAttributeGroup. | [
"Attributes",
"returns",
"a",
"slice",
"of",
"Attributes",
"in",
"this",
"BinaryAttributeGroup",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/bag.go#L30-L36 |
164,724 | sjwhitworth/golearn | base/bag.go | AddAttribute | func (b *BinaryAttributeGroup) AddAttribute(a Attribute) error {
b.attributes = append(b.attributes, a)
return nil
} | go | func (b *BinaryAttributeGroup) AddAttribute(a Attribute) error {
b.attributes = append(b.attributes, a)
return nil
} | [
"func",
"(",
"b",
"*",
"BinaryAttributeGroup",
")",
"AddAttribute",
"(",
"a",
"Attribute",
")",
"error",
"{",
"b",
".",
"attributes",
"=",
"append",
"(",
"b",
".",
"attributes",
",",
"a",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // AddAttribute adds an Attribute to this BinaryAttributeGroup | [
"AddAttribute",
"adds",
"an",
"Attribute",
"to",
"this",
"BinaryAttributeGroup"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/bag.go#L39-L42 |
164,725 | sjwhitworth/golearn | ensemble/randomforest.go | NewRandomForest | func NewRandomForest(forestSize int, features int) *RandomForest {
ret := &RandomForest{
base.BaseClassifier{},
forestSize,
features,
nil,
}
return ret
} | go | func NewRandomForest(forestSize int, features int) *RandomForest {
ret := &RandomForest{
base.BaseClassifier{},
forestSize,
features,
nil,
}
return ret
} | [
"func",
"NewRandomForest",
"(",
"forestSize",
"int",
",",
"features",
"int",
")",
"*",
"RandomForest",
"{",
"ret",
":=",
"&",
"RandomForest",
"{",
"base",
".",
"BaseClassifier",
"{",
"}",
",",
"forestSize",
",",
"features",
",",
"nil",
",",
"}",
"\n",
"r... | // NewRandomForest generates and return a new random forests
// forestSize controls the number of trees that get built
// features controls the number of features used to build each tree. | [
"NewRandomForest",
"generates",
"and",
"return",
"a",
"new",
"random",
"forests",
"forestSize",
"controls",
"the",
"number",
"of",
"trees",
"that",
"get",
"built",
"features",
"controls",
"the",
"number",
"of",
"features",
"used",
"to",
"build",
"each",
"tree",
... | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/ensemble/randomforest.go#L23-L31 |
164,726 | sjwhitworth/golearn | ensemble/randomforest.go | Fit | func (f *RandomForest) Fit(on base.FixedDataGrid) error {
numNonClassAttributes := len(base.NonClassAttributes(on))
if numNonClassAttributes < f.Features {
return errors.New(fmt.Sprintf(
"Random forest with %d features cannot fit data grid with %d non-class attributes",
f.Features,
numNonClassAttributes,
))
}
f.Model = new(meta.BaggedModel)
f.Model.RandomFeatures = f.Features
for i := 0; i < f.ForestSize; i++ {
tree := trees.NewID3DecisionTree(0.00)
f.Model.AddModel(tree)
}
f.Model.Fit(on)
return nil
} | go | func (f *RandomForest) Fit(on base.FixedDataGrid) error {
numNonClassAttributes := len(base.NonClassAttributes(on))
if numNonClassAttributes < f.Features {
return errors.New(fmt.Sprintf(
"Random forest with %d features cannot fit data grid with %d non-class attributes",
f.Features,
numNonClassAttributes,
))
}
f.Model = new(meta.BaggedModel)
f.Model.RandomFeatures = f.Features
for i := 0; i < f.ForestSize; i++ {
tree := trees.NewID3DecisionTree(0.00)
f.Model.AddModel(tree)
}
f.Model.Fit(on)
return nil
} | [
"func",
"(",
"f",
"*",
"RandomForest",
")",
"Fit",
"(",
"on",
"base",
".",
"FixedDataGrid",
")",
"error",
"{",
"numNonClassAttributes",
":=",
"len",
"(",
"base",
".",
"NonClassAttributes",
"(",
"on",
")",
")",
"\n",
"if",
"numNonClassAttributes",
"<",
"f",... | // Fit builds the RandomForest on the specified instances | [
"Fit",
"builds",
"the",
"RandomForest",
"on",
"the",
"specified",
"instances"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/ensemble/randomforest.go#L34-L52 |
164,727 | sjwhitworth/golearn | ensemble/randomforest.go | Predict | func (f *RandomForest) Predict(with base.FixedDataGrid) (base.FixedDataGrid, error) {
return f.Model.Predict(with)
} | go | func (f *RandomForest) Predict(with base.FixedDataGrid) (base.FixedDataGrid, error) {
return f.Model.Predict(with)
} | [
"func",
"(",
"f",
"*",
"RandomForest",
")",
"Predict",
"(",
"with",
"base",
".",
"FixedDataGrid",
")",
"(",
"base",
".",
"FixedDataGrid",
",",
"error",
")",
"{",
"return",
"f",
".",
"Model",
".",
"Predict",
"(",
"with",
")",
"\n",
"}"
] | // Predict generates predictions from a trained RandomForest. | [
"Predict",
"generates",
"predictions",
"from",
"a",
"trained",
"RandomForest",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/ensemble/randomforest.go#L55-L57 |
164,728 | sjwhitworth/golearn | ensemble/randomforest.go | String | func (f *RandomForest) String() string {
return fmt.Sprintf("RandomForest(ForestSize: %d, Features:%d, %s\n)", f.ForestSize, f.Features, f.Model)
} | go | func (f *RandomForest) String() string {
return fmt.Sprintf("RandomForest(ForestSize: %d, Features:%d, %s\n)", f.ForestSize, f.Features, f.Model)
} | [
"func",
"(",
"f",
"*",
"RandomForest",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"f",
".",
"ForestSize",
",",
"f",
".",
"Features",
",",
"f",
".",
"Model",
")",
"\n",
"}"
] | // String returns a human-readable representation of this tree. | [
"String",
"returns",
"a",
"human",
"-",
"readable",
"representation",
"of",
"this",
"tree",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/ensemble/randomforest.go#L60-L62 |
164,729 | sjwhitworth/golearn | base/util_instances.go | GeneratePredictionVector | func GeneratePredictionVector(from FixedDataGrid) UpdatableDataGrid {
classAttrs := from.AllClassAttributes()
_, rowCount := from.Size()
ret := NewDenseInstances()
for _, a := range classAttrs {
ret.AddAttribute(a)
ret.AddClassAttribute(a)
}
ret.Extend(rowCount)
return ret
} | go | func GeneratePredictionVector(from FixedDataGrid) UpdatableDataGrid {
classAttrs := from.AllClassAttributes()
_, rowCount := from.Size()
ret := NewDenseInstances()
for _, a := range classAttrs {
ret.AddAttribute(a)
ret.AddClassAttribute(a)
}
ret.Extend(rowCount)
return ret
} | [
"func",
"GeneratePredictionVector",
"(",
"from",
"FixedDataGrid",
")",
"UpdatableDataGrid",
"{",
"classAttrs",
":=",
"from",
".",
"AllClassAttributes",
"(",
")",
"\n",
"_",
",",
"rowCount",
":=",
"from",
".",
"Size",
"(",
")",
"\n",
"ret",
":=",
"NewDenseInsta... | // This file contains utility functions relating to efficiently
// generating predictions and instantiating DataGrid implementations.
// GeneratePredictionVector selects the class Attributes from a given
// FixedDataGrid and returns something which can hold the predictions. | [
"This",
"file",
"contains",
"utility",
"functions",
"relating",
"to",
"efficiently",
"generating",
"predictions",
"and",
"instantiating",
"DataGrid",
"implementations",
".",
"GeneratePredictionVector",
"selects",
"the",
"class",
"Attributes",
"from",
"a",
"given",
"Fixe... | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/util_instances.go#L13-L23 |
164,730 | sjwhitworth/golearn | base/util_instances.go | GetAttributeByName | func GetAttributeByName(inst FixedDataGrid, name string) Attribute {
for _, a := range inst.AllAttributes() {
if a.GetName() == name {
return a
}
}
return nil
} | go | func GetAttributeByName(inst FixedDataGrid, name string) Attribute {
for _, a := range inst.AllAttributes() {
if a.GetName() == name {
return a
}
}
return nil
} | [
"func",
"GetAttributeByName",
"(",
"inst",
"FixedDataGrid",
",",
"name",
"string",
")",
"Attribute",
"{",
"for",
"_",
",",
"a",
":=",
"range",
"inst",
".",
"AllAttributes",
"(",
")",
"{",
"if",
"a",
".",
"GetName",
"(",
")",
"==",
"name",
"{",
"return"... | // GetAttributeByName returns an Attribute matching a given name.
// Returns nil if one doesn't exist. | [
"GetAttributeByName",
"returns",
"an",
"Attribute",
"matching",
"a",
"given",
"name",
".",
"Returns",
"nil",
"if",
"one",
"doesn",
"t",
"exist",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/util_instances.go#L114-L121 |
164,731 | sjwhitworth/golearn | base/util_instances.go | GetClassDistributionByBinaryFloatValue | func GetClassDistributionByBinaryFloatValue(inst FixedDataGrid) []int {
// Get the class variable
attrs := inst.AllClassAttributes()
if len(attrs) != 1 {
panic(fmt.Errorf("Wrong number of class variables (has %d, should be 1)", len(attrs)))
}
if _, ok := attrs[0].(*FloatAttribute); !ok {
panic(fmt.Errorf("Class Attribute must be FloatAttribute (is %s)", attrs[0]))
}
// Get the number of class values
ret := make([]int, 2)
// Map through everything
specs := ResolveAttributes(inst, attrs)
inst.MapOverRows(specs, func(vals [][]byte, row int) (bool, error) {
index := UnpackBytesToFloat(vals[0])
if index > 0.5 {
ret[1]++
} else {
ret[0]++
}
return false, nil
})
return ret
} | go | func GetClassDistributionByBinaryFloatValue(inst FixedDataGrid) []int {
// Get the class variable
attrs := inst.AllClassAttributes()
if len(attrs) != 1 {
panic(fmt.Errorf("Wrong number of class variables (has %d, should be 1)", len(attrs)))
}
if _, ok := attrs[0].(*FloatAttribute); !ok {
panic(fmt.Errorf("Class Attribute must be FloatAttribute (is %s)", attrs[0]))
}
// Get the number of class values
ret := make([]int, 2)
// Map through everything
specs := ResolveAttributes(inst, attrs)
inst.MapOverRows(specs, func(vals [][]byte, row int) (bool, error) {
index := UnpackBytesToFloat(vals[0])
if index > 0.5 {
ret[1]++
} else {
ret[0]++
}
return false, nil
})
return ret
} | [
"func",
"GetClassDistributionByBinaryFloatValue",
"(",
"inst",
"FixedDataGrid",
")",
"[",
"]",
"int",
"{",
"// Get the class variable",
"attrs",
":=",
"inst",
".",
"AllClassAttributes",
"(",
")",
"\n",
"if",
"len",
"(",
"attrs",
")",
"!=",
"1",
"{",
"panic",
"... | // GetClassDistributionByBinaryFloatValue returns the count of each row
// which has a float value close to 0.0 or 1.0. | [
"GetClassDistributionByBinaryFloatValue",
"returns",
"the",
"count",
"of",
"each",
"row",
"which",
"has",
"a",
"float",
"value",
"close",
"to",
"0",
".",
"0",
"or",
"1",
".",
"0",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/util_instances.go#L125-L153 |
164,732 | sjwhitworth/golearn | base/util_instances.go | GetClassDistributionAfterThreshold | func GetClassDistributionAfterThreshold(inst FixedDataGrid, at Attribute, val float64) map[string]map[string]int {
ret := make(map[string]map[string]int)
// Find the attribute we're decomposing on
attrSpec, err := inst.GetAttribute(at)
if err != nil {
panic(fmt.Sprintf("Invalid attribute %s (%s)", at, err))
}
// Validate
if _, ok := at.(*FloatAttribute); !ok {
panic(fmt.Sprintf("Must be numeric!"))
}
_, rows := inst.Size()
for i := 0; i < rows; i++ {
splitVal := UnpackBytesToFloat(inst.Get(attrSpec, i)) > val
splitVar := "0"
if splitVal {
splitVar = "1"
}
classVar := GetClass(inst, i)
if _, ok := ret[splitVar]; !ok {
ret[splitVar] = make(map[string]int)
i--
continue
}
ret[splitVar][classVar]++
}
return ret
} | go | func GetClassDistributionAfterThreshold(inst FixedDataGrid, at Attribute, val float64) map[string]map[string]int {
ret := make(map[string]map[string]int)
// Find the attribute we're decomposing on
attrSpec, err := inst.GetAttribute(at)
if err != nil {
panic(fmt.Sprintf("Invalid attribute %s (%s)", at, err))
}
// Validate
if _, ok := at.(*FloatAttribute); !ok {
panic(fmt.Sprintf("Must be numeric!"))
}
_, rows := inst.Size()
for i := 0; i < rows; i++ {
splitVal := UnpackBytesToFloat(inst.Get(attrSpec, i)) > val
splitVar := "0"
if splitVal {
splitVar = "1"
}
classVar := GetClass(inst, i)
if _, ok := ret[splitVar]; !ok {
ret[splitVar] = make(map[string]int)
i--
continue
}
ret[splitVar][classVar]++
}
return ret
} | [
"func",
"GetClassDistributionAfterThreshold",
"(",
"inst",
"FixedDataGrid",
",",
"at",
"Attribute",
",",
"val",
"float64",
")",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"int",
"{",
"ret",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
... | // GetClassDistributionAfterThreshold returns the class distribution
// after a speculative split on a given Attribute using a threshold. | [
"GetClassDistributionAfterThreshold",
"returns",
"the",
"class",
"distribution",
"after",
"a",
"speculative",
"split",
"on",
"a",
"given",
"Attribute",
"using",
"a",
"threshold",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/util_instances.go#L200-L232 |
164,733 | sjwhitworth/golearn | base/util_instances.go | GetClassDistributionAfterSplit | func GetClassDistributionAfterSplit(inst FixedDataGrid, at Attribute) map[string]map[string]int {
ret := make(map[string]map[string]int)
// Find the attribute we're decomposing on
attrSpec, err := inst.GetAttribute(at)
if err != nil {
panic(fmt.Sprintf("Invalid attribute %s (%s)", at, err))
}
_, rows := inst.Size()
for i := 0; i < rows; i++ {
splitVar := at.GetStringFromSysVal(inst.Get(attrSpec, i))
classVar := GetClass(inst, i)
if _, ok := ret[splitVar]; !ok {
ret[splitVar] = make(map[string]int)
i--
continue
}
ret[splitVar][classVar]++
}
return ret
} | go | func GetClassDistributionAfterSplit(inst FixedDataGrid, at Attribute) map[string]map[string]int {
ret := make(map[string]map[string]int)
// Find the attribute we're decomposing on
attrSpec, err := inst.GetAttribute(at)
if err != nil {
panic(fmt.Sprintf("Invalid attribute %s (%s)", at, err))
}
_, rows := inst.Size()
for i := 0; i < rows; i++ {
splitVar := at.GetStringFromSysVal(inst.Get(attrSpec, i))
classVar := GetClass(inst, i)
if _, ok := ret[splitVar]; !ok {
ret[splitVar] = make(map[string]int)
i--
continue
}
ret[splitVar][classVar]++
}
return ret
} | [
"func",
"GetClassDistributionAfterSplit",
"(",
"inst",
"FixedDataGrid",
",",
"at",
"Attribute",
")",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"int",
"{",
"ret",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"int",
... | // GetClassDistributionAfterSplit returns the class distribution
// after a speculative split on a given Attribute. | [
"GetClassDistributionAfterSplit",
"returns",
"the",
"class",
"distribution",
"after",
"a",
"speculative",
"split",
"on",
"a",
"given",
"Attribute",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/util_instances.go#L236-L260 |
164,734 | sjwhitworth/golearn | base/util_instances.go | LazyShuffle | func LazyShuffle(from FixedDataGrid) FixedDataGrid {
_, rows := from.Size()
rowMap := make(map[int]int)
for i := 0; i < rows; i++ {
j := rand.Intn(i + 1)
rowMap[i] = j
rowMap[j] = i
}
return NewInstancesViewFromRows(from, rowMap)
} | go | func LazyShuffle(from FixedDataGrid) FixedDataGrid {
_, rows := from.Size()
rowMap := make(map[int]int)
for i := 0; i < rows; i++ {
j := rand.Intn(i + 1)
rowMap[i] = j
rowMap[j] = i
}
return NewInstancesViewFromRows(from, rowMap)
} | [
"func",
"LazyShuffle",
"(",
"from",
"FixedDataGrid",
")",
"FixedDataGrid",
"{",
"_",
",",
"rows",
":=",
"from",
".",
"Size",
"(",
")",
"\n",
"rowMap",
":=",
"make",
"(",
"map",
"[",
"int",
"]",
"int",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"... | // LazyShuffle randomizes the row order without re-ordering the rows
// via an InstancesView. | [
"LazyShuffle",
"randomizes",
"the",
"row",
"order",
"without",
"re",
"-",
"ordering",
"the",
"rows",
"via",
"an",
"InstancesView",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/util_instances.go#L400-L409 |
164,735 | sjwhitworth/golearn | base/util_instances.go | CheckCompatible | func CheckCompatible(s1 FixedDataGrid, s2 FixedDataGrid) []Attribute {
s1Attrs := s1.AllAttributes()
s2Attrs := s2.AllAttributes()
interAttrs := AttributeIntersect(s1Attrs, s2Attrs)
if len(interAttrs) != len(s1Attrs) {
return nil
} else if len(interAttrs) != len(s2Attrs) {
return nil
}
return interAttrs
} | go | func CheckCompatible(s1 FixedDataGrid, s2 FixedDataGrid) []Attribute {
s1Attrs := s1.AllAttributes()
s2Attrs := s2.AllAttributes()
interAttrs := AttributeIntersect(s1Attrs, s2Attrs)
if len(interAttrs) != len(s1Attrs) {
return nil
} else if len(interAttrs) != len(s2Attrs) {
return nil
}
return interAttrs
} | [
"func",
"CheckCompatible",
"(",
"s1",
"FixedDataGrid",
",",
"s2",
"FixedDataGrid",
")",
"[",
"]",
"Attribute",
"{",
"s1Attrs",
":=",
"s1",
".",
"AllAttributes",
"(",
")",
"\n",
"s2Attrs",
":=",
"s2",
".",
"AllAttributes",
"(",
")",
"\n",
"interAttrs",
":="... | // CheckCompatible checks whether two DataGrids have the same Attributes
// and if they do, it returns them. | [
"CheckCompatible",
"checks",
"whether",
"two",
"DataGrids",
"have",
"the",
"same",
"Attributes",
"and",
"if",
"they",
"do",
"it",
"returns",
"them",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/util_instances.go#L443-L453 |
164,736 | sjwhitworth/golearn | base/util_instances.go | CheckStrictlyCompatible | func CheckStrictlyCompatible(s1 FixedDataGrid, s2 FixedDataGrid) bool {
// Cast
d1, ok1 := s1.(*DenseInstances)
d2, ok2 := s2.(*DenseInstances)
if !ok1 || !ok2 {
return false
}
// Retrieve AttributeGroups
d1ags := d1.AllAttributeGroups()
d2ags := d2.AllAttributeGroups()
// Check everything in d1 is in d2
for a := range d1ags {
_, ok := d2ags[a]
if !ok {
return false
}
}
// Check everything in d2 is in d1
for a := range d2ags {
_, ok := d1ags[a]
if !ok {
return false
}
}
// Check that everything has the same number
// of equivalent Attributes, in the same order
for a := range d1ags {
ag1 := d1ags[a]
ag2 := d2ags[a]
a1 := ag1.Attributes()
a2 := ag2.Attributes()
for i := range a1 {
at1 := a1[i]
at2 := a2[i]
if !at1.Equals(at2) {
return false
}
}
}
return true
} | go | func CheckStrictlyCompatible(s1 FixedDataGrid, s2 FixedDataGrid) bool {
// Cast
d1, ok1 := s1.(*DenseInstances)
d2, ok2 := s2.(*DenseInstances)
if !ok1 || !ok2 {
return false
}
// Retrieve AttributeGroups
d1ags := d1.AllAttributeGroups()
d2ags := d2.AllAttributeGroups()
// Check everything in d1 is in d2
for a := range d1ags {
_, ok := d2ags[a]
if !ok {
return false
}
}
// Check everything in d2 is in d1
for a := range d2ags {
_, ok := d1ags[a]
if !ok {
return false
}
}
// Check that everything has the same number
// of equivalent Attributes, in the same order
for a := range d1ags {
ag1 := d1ags[a]
ag2 := d2ags[a]
a1 := ag1.Attributes()
a2 := ag2.Attributes()
for i := range a1 {
at1 := a1[i]
at2 := a2[i]
if !at1.Equals(at2) {
return false
}
}
}
return true
} | [
"func",
"CheckStrictlyCompatible",
"(",
"s1",
"FixedDataGrid",
",",
"s2",
"FixedDataGrid",
")",
"bool",
"{",
"// Cast",
"d1",
",",
"ok1",
":=",
"s1",
".",
"(",
"*",
"DenseInstances",
")",
"\n",
"d2",
",",
"ok2",
":=",
"s2",
".",
"(",
"*",
"DenseInstances... | // CheckStrictlyCompatible checks whether two DenseInstances have
// AttributeGroups with the same Attributes, in the same order,
// enabling optimisations. | [
"CheckStrictlyCompatible",
"checks",
"whether",
"two",
"DenseInstances",
"have",
"AttributeGroups",
"with",
"the",
"same",
"Attributes",
"in",
"the",
"same",
"order",
"enabling",
"optimisations",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/util_instances.go#L458-L503 |
164,737 | sjwhitworth/golearn | filters/binning.go | NewBinningFilter | func NewBinningFilter(d base.FixedDataGrid, bins int) *BinningFilter {
return &BinningFilter{
AbstractDiscretizeFilter{
make(map[base.Attribute]bool),
false,
d,
},
bins,
make(map[base.Attribute]float64),
make(map[base.Attribute]float64),
}
} | go | func NewBinningFilter(d base.FixedDataGrid, bins int) *BinningFilter {
return &BinningFilter{
AbstractDiscretizeFilter{
make(map[base.Attribute]bool),
false,
d,
},
bins,
make(map[base.Attribute]float64),
make(map[base.Attribute]float64),
}
} | [
"func",
"NewBinningFilter",
"(",
"d",
"base",
".",
"FixedDataGrid",
",",
"bins",
"int",
")",
"*",
"BinningFilter",
"{",
"return",
"&",
"BinningFilter",
"{",
"AbstractDiscretizeFilter",
"{",
"make",
"(",
"map",
"[",
"base",
".",
"Attribute",
"]",
"bool",
")",... | // NewBinningFilter creates a BinningFilter structure
// with some helpful default initialisations. | [
"NewBinningFilter",
"creates",
"a",
"BinningFilter",
"structure",
"with",
"some",
"helpful",
"default",
"initialisations",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/filters/binning.go#L21-L32 |
164,738 | sjwhitworth/golearn | filters/binning.go | Train | func (b *BinningFilter) Train() error {
as := b.getAttributeSpecs()
// Set up the AttributeSpecs, and values
for attr := range b.attrs {
if !b.attrs[attr] {
continue
}
b.minVals[attr] = float64(math.Inf(1))
b.maxVals[attr] = float64(math.Inf(-1))
}
err := b.train.MapOverRows(as, func(row [][]byte, rowNo int) (bool, error) {
for i, a := range row {
attr := as[i].GetAttribute()
attrf := attr.(*base.FloatAttribute)
val := float64(attrf.GetFloatFromSysVal(a))
if val > b.maxVals[attr] {
b.maxVals[attr] = val
}
if val < b.minVals[attr] {
b.minVals[attr] = val
}
}
return true, nil
})
if err != nil {
return fmt.Errorf("Training error: %s", err)
}
b.trained = true
return nil
} | go | func (b *BinningFilter) Train() error {
as := b.getAttributeSpecs()
// Set up the AttributeSpecs, and values
for attr := range b.attrs {
if !b.attrs[attr] {
continue
}
b.minVals[attr] = float64(math.Inf(1))
b.maxVals[attr] = float64(math.Inf(-1))
}
err := b.train.MapOverRows(as, func(row [][]byte, rowNo int) (bool, error) {
for i, a := range row {
attr := as[i].GetAttribute()
attrf := attr.(*base.FloatAttribute)
val := float64(attrf.GetFloatFromSysVal(a))
if val > b.maxVals[attr] {
b.maxVals[attr] = val
}
if val < b.minVals[attr] {
b.minVals[attr] = val
}
}
return true, nil
})
if err != nil {
return fmt.Errorf("Training error: %s", err)
}
b.trained = true
return nil
} | [
"func",
"(",
"b",
"*",
"BinningFilter",
")",
"Train",
"(",
")",
"error",
"{",
"as",
":=",
"b",
".",
"getAttributeSpecs",
"(",
")",
"\n",
"// Set up the AttributeSpecs, and values",
"for",
"attr",
":=",
"range",
"b",
".",
"attrs",
"{",
"if",
"!",
"b",
"."... | // Train computes and stores the bin values
// for the training instances. | [
"Train",
"computes",
"and",
"stores",
"the",
"bin",
"values",
"for",
"the",
"training",
"instances",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/filters/binning.go#L40-L72 |
164,739 | sjwhitworth/golearn | filters/binning.go | Transform | func (b *BinningFilter) Transform(a base.Attribute, n base.Attribute, field []byte) []byte {
if !b.attrs[a] {
return field
}
af, ok := a.(*base.FloatAttribute)
if !ok {
panic("Attribute is the wrong type")
}
minVal := b.minVals[a]
maxVal := b.maxVals[a]
disc := 0
// Casts to float64 to replicate a floating point precision error
delta := float64(maxVal-minVal) / float64(b.bins)
val := float64(af.GetFloatFromSysVal(field))
if val <= minVal {
disc = 0
} else {
disc = int(math.Floor(float64(float64(val-minVal)/delta + 0.0001)))
}
return base.PackU64ToBytes(uint64(disc))
} | go | func (b *BinningFilter) Transform(a base.Attribute, n base.Attribute, field []byte) []byte {
if !b.attrs[a] {
return field
}
af, ok := a.(*base.FloatAttribute)
if !ok {
panic("Attribute is the wrong type")
}
minVal := b.minVals[a]
maxVal := b.maxVals[a]
disc := 0
// Casts to float64 to replicate a floating point precision error
delta := float64(maxVal-minVal) / float64(b.bins)
val := float64(af.GetFloatFromSysVal(field))
if val <= minVal {
disc = 0
} else {
disc = int(math.Floor(float64(float64(val-minVal)/delta + 0.0001)))
}
return base.PackU64ToBytes(uint64(disc))
} | [
"func",
"(",
"b",
"*",
"BinningFilter",
")",
"Transform",
"(",
"a",
"base",
".",
"Attribute",
",",
"n",
"base",
".",
"Attribute",
",",
"field",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"if",
"!",
"b",
".",
"attrs",
"[",
"a",
"]",
"{",
"ret... | // Transform takes an Attribute and byte sequence and returns
// the transformed byte sequence. | [
"Transform",
"takes",
"an",
"Attribute",
"and",
"byte",
"sequence",
"and",
"returns",
"the",
"transformed",
"byte",
"sequence",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/filters/binning.go#L76-L97 |
164,740 | sjwhitworth/golearn | base/serialize_attributes.go | MarshalAttribute | func MarshalAttribute(a Attribute) (map[string]interface{}, error) {
ret := make(map[string]interface{})
marshaledAttrRaw, err := a.MarshalJSON()
if err != nil {
return nil, err
}
err = json.Unmarshal(marshaledAttrRaw, &ret)
if err != nil {
return nil, err
}
return ret, nil
} | go | func MarshalAttribute(a Attribute) (map[string]interface{}, error) {
ret := make(map[string]interface{})
marshaledAttrRaw, err := a.MarshalJSON()
if err != nil {
return nil, err
}
err = json.Unmarshal(marshaledAttrRaw, &ret)
if err != nil {
return nil, err
}
return ret, nil
} | [
"func",
"MarshalAttribute",
"(",
"a",
"Attribute",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"ret",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"marshaledAttrRaw",
",",
"er... | // MarshalAttribute converts an Attribute to a JSON map. | [
"MarshalAttribute",
"converts",
"an",
"Attribute",
"to",
"a",
"JSON",
"map",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/serialize_attributes.go#L34-L45 |
164,741 | sjwhitworth/golearn | base/serialize_attributes.go | DeserializeAttributes | func DeserializeAttributes(data []byte) ([]Attribute, error) {
// Define a JSON shim Attribute
var attrs []json.RawMessage
err := json.Unmarshal(data, &attrs)
if err != nil {
return nil, fmt.Errorf("Failed to deserialize attributes: %v", err)
}
ret := make([]Attribute, len(attrs))
for i, v := range attrs {
ret[i], err = DeserializeAttribute(v)
if err != nil {
return nil, err
}
}
return ret, nil
} | go | func DeserializeAttributes(data []byte) ([]Attribute, error) {
// Define a JSON shim Attribute
var attrs []json.RawMessage
err := json.Unmarshal(data, &attrs)
if err != nil {
return nil, fmt.Errorf("Failed to deserialize attributes: %v", err)
}
ret := make([]Attribute, len(attrs))
for i, v := range attrs {
ret[i], err = DeserializeAttribute(v)
if err != nil {
return nil, err
}
}
return ret, nil
} | [
"func",
"DeserializeAttributes",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"Attribute",
",",
"error",
")",
"{",
"// Define a JSON shim Attribute",
"var",
"attrs",
"[",
"]",
"json",
".",
"RawMessage",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(... | // DeserializeAttributes constructs a ve | [
"DeserializeAttributes",
"constructs",
"a",
"ve"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/serialize_attributes.go#L93-L111 |
164,742 | sjwhitworth/golearn | base/serialize_attributes.go | ReplaceDeserializedAttributeWithVersionFromInstances | func ReplaceDeserializedAttributeWithVersionFromInstances(deserialized Attribute, matchingWith FixedDataGrid) (Attribute, error) {
for _, a := range matchingWith.AllAttributes() {
if a.Equals(deserialized) {
return a, nil
}
}
return nil, WrapError(fmt.Errorf("Unable to match %v in %v", deserialized, matchingWith))
} | go | func ReplaceDeserializedAttributeWithVersionFromInstances(deserialized Attribute, matchingWith FixedDataGrid) (Attribute, error) {
for _, a := range matchingWith.AllAttributes() {
if a.Equals(deserialized) {
return a, nil
}
}
return nil, WrapError(fmt.Errorf("Unable to match %v in %v", deserialized, matchingWith))
} | [
"func",
"ReplaceDeserializedAttributeWithVersionFromInstances",
"(",
"deserialized",
"Attribute",
",",
"matchingWith",
"FixedDataGrid",
")",
"(",
"Attribute",
",",
"error",
")",
"{",
"for",
"_",
",",
"a",
":=",
"range",
"matchingWith",
".",
"AllAttributes",
"(",
")"... | // ReplaceDeserializedAttributeWithVersionFromInstances takes an independently deserialized Attribute and matches it
// if possible with one from a candidate FixedDataGrid. | [
"ReplaceDeserializedAttributeWithVersionFromInstances",
"takes",
"an",
"independently",
"deserialized",
"Attribute",
"and",
"matches",
"it",
"if",
"possible",
"with",
"one",
"from",
"a",
"candidate",
"FixedDataGrid",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/serialize_attributes.go#L115-L122 |
164,743 | sjwhitworth/golearn | base/serialize_attributes.go | ReplaceDeserializedAttributesWithVersionsFromInstances | func ReplaceDeserializedAttributesWithVersionsFromInstances(deserialized []Attribute, matchingWith FixedDataGrid) ([]Attribute, error) {
ret := make([]Attribute, len(deserialized))
for i, a := range deserialized {
match, err := ReplaceDeserializedAttributeWithVersionFromInstances(a, matchingWith)
if err != nil {
return nil, WrapError(err)
}
ret[i] = match
}
return ret, nil
} | go | func ReplaceDeserializedAttributesWithVersionsFromInstances(deserialized []Attribute, matchingWith FixedDataGrid) ([]Attribute, error) {
ret := make([]Attribute, len(deserialized))
for i, a := range deserialized {
match, err := ReplaceDeserializedAttributeWithVersionFromInstances(a, matchingWith)
if err != nil {
return nil, WrapError(err)
}
ret[i] = match
}
return ret, nil
} | [
"func",
"ReplaceDeserializedAttributesWithVersionsFromInstances",
"(",
"deserialized",
"[",
"]",
"Attribute",
",",
"matchingWith",
"FixedDataGrid",
")",
"(",
"[",
"]",
"Attribute",
",",
"error",
")",
"{",
"ret",
":=",
"make",
"(",
"[",
"]",
"Attribute",
",",
"le... | // ReplaceDeserializedAttributesWithVersionsFromInstances takes some independently loaded Attributes and
// matches them up with a candidate FixedDataGrid. | [
"ReplaceDeserializedAttributesWithVersionsFromInstances",
"takes",
"some",
"independently",
"loaded",
"Attributes",
"and",
"matches",
"them",
"up",
"with",
"a",
"candidate",
"FixedDataGrid",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/serialize_attributes.go#L126-L136 |
164,744 | sjwhitworth/golearn | base/dense.go | NewDenseInstances | func NewDenseInstances() *DenseInstances {
return &DenseInstances{
make(map[string]int),
make(map[int]string),
make([]AttributeGroup, 0),
sync.Mutex{},
false,
make(map[AttributeSpec]bool),
0,
make([]Attribute, 0),
make(map[Attribute]string),
0,
0,
0,
}
} | go | func NewDenseInstances() *DenseInstances {
return &DenseInstances{
make(map[string]int),
make(map[int]string),
make([]AttributeGroup, 0),
sync.Mutex{},
false,
make(map[AttributeSpec]bool),
0,
make([]Attribute, 0),
make(map[Attribute]string),
0,
0,
0,
}
} | [
"func",
"NewDenseInstances",
"(",
")",
"*",
"DenseInstances",
"{",
"return",
"&",
"DenseInstances",
"{",
"make",
"(",
"map",
"[",
"string",
"]",
"int",
")",
",",
"make",
"(",
"map",
"[",
"int",
"]",
"string",
")",
",",
"make",
"(",
"[",
"]",
"Attribu... | // NewDenseInstances generates a new DenseInstances set
// with an anonymous EDF mapping and default settings. | [
"NewDenseInstances",
"generates",
"a",
"new",
"DenseInstances",
"set",
"with",
"an",
"anonymous",
"EDF",
"mapping",
"and",
"default",
"settings",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L30-L45 |
164,745 | sjwhitworth/golearn | base/dense.go | NewStructuralCopy | func NewStructuralCopy(of FixedDataGrid) *DenseInstances {
ret, _, _ := copyFixedDataGridStructure(of)
return ret
} | go | func NewStructuralCopy(of FixedDataGrid) *DenseInstances {
ret, _, _ := copyFixedDataGridStructure(of)
return ret
} | [
"func",
"NewStructuralCopy",
"(",
"of",
"FixedDataGrid",
")",
"*",
"DenseInstances",
"{",
"ret",
",",
"_",
",",
"_",
":=",
"copyFixedDataGridStructure",
"(",
"of",
")",
"\n",
"return",
"ret",
"\n",
"}"
] | // NewStructuralCopy generates an empty DenseInstances with the same layout as
// an existing FixedDataGrid, but with no data. | [
"NewStructuralCopy",
"generates",
"an",
"empty",
"DenseInstances",
"with",
"the",
"same",
"layout",
"as",
"an",
"existing",
"FixedDataGrid",
"but",
"with",
"no",
"data",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L74-L77 |
164,746 | sjwhitworth/golearn | base/dense.go | NewDenseCopy | func NewDenseCopy(of FixedDataGrid) *DenseInstances {
ret, specs1, specs2 := copyFixedDataGridStructure(of)
// Allocate memory
_, rows := of.Size()
ret.Extend(rows)
// Copy each row from the old one to the new
of.MapOverRows(specs1, func(v [][]byte, r int) (bool, error) {
for i, c := range v {
ret.Set(specs2[i], r, c)
}
return true, nil
})
return ret
} | go | func NewDenseCopy(of FixedDataGrid) *DenseInstances {
ret, specs1, specs2 := copyFixedDataGridStructure(of)
// Allocate memory
_, rows := of.Size()
ret.Extend(rows)
// Copy each row from the old one to the new
of.MapOverRows(specs1, func(v [][]byte, r int) (bool, error) {
for i, c := range v {
ret.Set(specs2[i], r, c)
}
return true, nil
})
return ret
} | [
"func",
"NewDenseCopy",
"(",
"of",
"FixedDataGrid",
")",
"*",
"DenseInstances",
"{",
"ret",
",",
"specs1",
",",
"specs2",
":=",
"copyFixedDataGridStructure",
"(",
"of",
")",
"\n\n",
"// Allocate memory",
"_",
",",
"rows",
":=",
"of",
".",
"Size",
"(",
")",
... | // NewDenseCopy generates a new DenseInstances set
// from an existing FixedDataGrid. | [
"NewDenseCopy",
"generates",
"a",
"new",
"DenseInstances",
"set",
"from",
"an",
"existing",
"FixedDataGrid",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L81-L98 |
164,747 | sjwhitworth/golearn | base/dense.go | CreateAttributeGroup | func (inst *DenseInstances) CreateAttributeGroup(name string, size int) (err error) {
defer func() {
if r := recover(); r != nil {
var ok bool
if err, ok = r.(error); !ok {
err = fmt.Errorf("CreateAttributeGroup: %v (not created)", r)
}
}
}()
inst.lock.Lock()
defer inst.lock.Unlock()
inst.createAttributeGroup(name, size)
return nil
} | go | func (inst *DenseInstances) CreateAttributeGroup(name string, size int) (err error) {
defer func() {
if r := recover(); r != nil {
var ok bool
if err, ok = r.(error); !ok {
err = fmt.Errorf("CreateAttributeGroup: %v (not created)", r)
}
}
}()
inst.lock.Lock()
defer inst.lock.Unlock()
inst.createAttributeGroup(name, size)
return nil
} | [
"func",
"(",
"inst",
"*",
"DenseInstances",
")",
"CreateAttributeGroup",
"(",
"name",
"string",
",",
"size",
"int",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{"... | // CreateAttributeGroup adds a new AttributeGroup to this set of instances
// with a given name. If the size is 0, a bit-ag is added
// if the size of not 0, then the size of each ag attribute
// is set to that number of bytes. | [
"CreateAttributeGroup",
"adds",
"a",
"new",
"AttributeGroup",
"to",
"this",
"set",
"of",
"instances",
"with",
"a",
"given",
"name",
".",
"If",
"the",
"size",
"is",
"0",
"a",
"bit",
"-",
"ag",
"is",
"added",
"if",
"the",
"size",
"of",
"not",
"0",
"then"... | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L139-L154 |
164,748 | sjwhitworth/golearn | base/dense.go | AllAttributeGroups | func (inst *DenseInstances) AllAttributeGroups() map[string]AttributeGroup {
ret := make(map[string]AttributeGroup)
for a := range inst.agMap {
ret[a] = inst.ags[inst.agMap[a]]
}
return ret
} | go | func (inst *DenseInstances) AllAttributeGroups() map[string]AttributeGroup {
ret := make(map[string]AttributeGroup)
for a := range inst.agMap {
ret[a] = inst.ags[inst.agMap[a]]
}
return ret
} | [
"func",
"(",
"inst",
"*",
"DenseInstances",
")",
"AllAttributeGroups",
"(",
")",
"map",
"[",
"string",
"]",
"AttributeGroup",
"{",
"ret",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"AttributeGroup",
")",
"\n",
"for",
"a",
":=",
"range",
"inst",
".",
... | // AllAttributeGroups returns a copy of the available AttributeGroups | [
"AllAttributeGroups",
"returns",
"a",
"copy",
"of",
"the",
"available",
"AttributeGroups"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L157-L163 |
164,749 | sjwhitworth/golearn | base/dense.go | AddAttributeToAttributeGroup | func (inst *DenseInstances) AddAttributeToAttributeGroup(newAttribute Attribute, ag string) (AttributeSpec, error) {
inst.lock.Lock()
defer inst.lock.Unlock()
// Check if the ag exists
if _, ok := inst.agMap[ag]; !ok {
return AttributeSpec{-1, 0, nil}, fmt.Errorf("AttributeGroup '%s' doesn't exist. Call CreateAttributeGroup() first", ag)
}
id := inst.agMap[ag]
p := inst.ags[id]
for i, a := range p.Attributes() {
if !a.Compatible(newAttribute) {
return AttributeSpec{-1, 0, nil}, fmt.Errorf("Attribute %s is not Compatible with %s in pond '%s' (position %d)", newAttribute, a, ag, i)
}
}
p.AddAttribute(newAttribute)
inst.attributes = append(inst.attributes, newAttribute)
return AttributeSpec{id, len(p.Attributes()) - 1, newAttribute}, nil
} | go | func (inst *DenseInstances) AddAttributeToAttributeGroup(newAttribute Attribute, ag string) (AttributeSpec, error) {
inst.lock.Lock()
defer inst.lock.Unlock()
// Check if the ag exists
if _, ok := inst.agMap[ag]; !ok {
return AttributeSpec{-1, 0, nil}, fmt.Errorf("AttributeGroup '%s' doesn't exist. Call CreateAttributeGroup() first", ag)
}
id := inst.agMap[ag]
p := inst.ags[id]
for i, a := range p.Attributes() {
if !a.Compatible(newAttribute) {
return AttributeSpec{-1, 0, nil}, fmt.Errorf("Attribute %s is not Compatible with %s in pond '%s' (position %d)", newAttribute, a, ag, i)
}
}
p.AddAttribute(newAttribute)
inst.attributes = append(inst.attributes, newAttribute)
return AttributeSpec{id, len(p.Attributes()) - 1, newAttribute}, nil
} | [
"func",
"(",
"inst",
"*",
"DenseInstances",
")",
"AddAttributeToAttributeGroup",
"(",
"newAttribute",
"Attribute",
",",
"ag",
"string",
")",
"(",
"AttributeSpec",
",",
"error",
")",
"{",
"inst",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"inst",
".... | // AddAttributeToAttributeGroup adds an Attribute to a given ag | [
"AddAttributeToAttributeGroup",
"adds",
"an",
"Attribute",
"to",
"a",
"given",
"ag"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L236-L256 |
164,750 | sjwhitworth/golearn | base/dense.go | AllAttributes | func (inst *DenseInstances) AllAttributes() []Attribute {
inst.lock.Lock()
defer inst.lock.Unlock()
ret := make([]Attribute, 0)
for _, p := range inst.ags {
for _, a := range p.Attributes() {
ret = append(ret, a)
}
}
return ret
} | go | func (inst *DenseInstances) AllAttributes() []Attribute {
inst.lock.Lock()
defer inst.lock.Unlock()
ret := make([]Attribute, 0)
for _, p := range inst.ags {
for _, a := range p.Attributes() {
ret = append(ret, a)
}
}
return ret
} | [
"func",
"(",
"inst",
"*",
"DenseInstances",
")",
"AllAttributes",
"(",
")",
"[",
"]",
"Attribute",
"{",
"inst",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"inst",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"ret",
":=",
"make",
"(",
"[",
... | // AllAttributes returns a slice of all Attributes. | [
"AllAttributes",
"returns",
"a",
"slice",
"of",
"all",
"Attributes",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L279-L291 |
164,751 | sjwhitworth/golearn | base/dense.go | AddClassAttribute | func (inst *DenseInstances) AddClassAttribute(a Attribute) error {
as, err := inst.GetAttribute(a)
if err != nil {
return err
}
inst.lock.Lock()
defer inst.lock.Unlock()
inst.classAttrs[as] = true
return nil
} | go | func (inst *DenseInstances) AddClassAttribute(a Attribute) error {
as, err := inst.GetAttribute(a)
if err != nil {
return err
}
inst.lock.Lock()
defer inst.lock.Unlock()
inst.classAttrs[as] = true
return nil
} | [
"func",
"(",
"inst",
"*",
"DenseInstances",
")",
"AddClassAttribute",
"(",
"a",
"Attribute",
")",
"error",
"{",
"as",
",",
"err",
":=",
"inst",
".",
"GetAttribute",
"(",
"a",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n... | // AddClassAttribute sets an Attribute to be a class Attribute. | [
"AddClassAttribute",
"sets",
"an",
"Attribute",
"to",
"be",
"a",
"class",
"Attribute",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L294-L306 |
164,752 | sjwhitworth/golearn | base/dense.go | RemoveClassAttribute | func (inst *DenseInstances) RemoveClassAttribute(a Attribute) error {
as, err := inst.GetAttribute(a)
if err != nil {
return err
}
inst.lock.Lock()
defer inst.lock.Unlock()
inst.classAttrs[as] = false
return nil
} | go | func (inst *DenseInstances) RemoveClassAttribute(a Attribute) error {
as, err := inst.GetAttribute(a)
if err != nil {
return err
}
inst.lock.Lock()
defer inst.lock.Unlock()
inst.classAttrs[as] = false
return nil
} | [
"func",
"(",
"inst",
"*",
"DenseInstances",
")",
"RemoveClassAttribute",
"(",
"a",
"Attribute",
")",
"error",
"{",
"as",
",",
"err",
":=",
"inst",
".",
"GetAttribute",
"(",
"a",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\... | // RemoveClassAttribute removes an Attribute from the set of class Attributes. | [
"RemoveClassAttribute",
"removes",
"an",
"Attribute",
"from",
"the",
"set",
"of",
"class",
"Attributes",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L309-L321 |
164,753 | sjwhitworth/golearn | base/dense.go | AllClassAttributes | func (inst *DenseInstances) AllClassAttributes() []Attribute {
inst.lock.Lock()
defer inst.lock.Unlock()
return inst.allClassAttributes()
} | go | func (inst *DenseInstances) AllClassAttributes() []Attribute {
inst.lock.Lock()
defer inst.lock.Unlock()
return inst.allClassAttributes()
} | [
"func",
"(",
"inst",
"*",
"DenseInstances",
")",
"AllClassAttributes",
"(",
")",
"[",
"]",
"Attribute",
"{",
"inst",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"inst",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"inst",
".",
"allCla... | // AllClassAttributes returns a slice of Attributes which have
// been designated class Attributes. | [
"AllClassAttributes",
"returns",
"a",
"slice",
"of",
"Attributes",
"which",
"have",
"been",
"designated",
"class",
"Attributes",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L325-L329 |
164,754 | sjwhitworth/golearn | base/dense.go | realiseAttributeGroups | func (inst *DenseInstances) realiseAttributeGroups() error {
for a := range inst.tmpAttrAgMap {
// Generate a default AttributeGroup name
ag := inst.tmpAttrAgMap[a]
// Augment with some additional information
// Find out whether this attribute is also a class
classAttribute := false
for _, c := range inst.allClassAttributes() {
if c.Equals(a) {
classAttribute = true
}
}
// This might result in multiple ClassAttribute groups
// but hopefully nothing too crazy
if classAttribute {
// ag = fmt.Sprintf("CLASS_%s", ag)
}
// Create the ag if it doesn't exist
if agId, ok := inst.agMap[ag]; !ok {
_, generatingBinClass := inst.ags[agId].(*BinaryAttributeGroup)
if !generatingBinClass {
inst.createAttributeGroup(ag, 8)
} else {
inst.createAttributeGroup(ag, 0)
}
}
id := inst.agMap[ag]
p := inst.ags[id]
err := p.AddAttribute(a)
if err != nil {
return err
}
}
return nil
} | go | func (inst *DenseInstances) realiseAttributeGroups() error {
for a := range inst.tmpAttrAgMap {
// Generate a default AttributeGroup name
ag := inst.tmpAttrAgMap[a]
// Augment with some additional information
// Find out whether this attribute is also a class
classAttribute := false
for _, c := range inst.allClassAttributes() {
if c.Equals(a) {
classAttribute = true
}
}
// This might result in multiple ClassAttribute groups
// but hopefully nothing too crazy
if classAttribute {
// ag = fmt.Sprintf("CLASS_%s", ag)
}
// Create the ag if it doesn't exist
if agId, ok := inst.agMap[ag]; !ok {
_, generatingBinClass := inst.ags[agId].(*BinaryAttributeGroup)
if !generatingBinClass {
inst.createAttributeGroup(ag, 8)
} else {
inst.createAttributeGroup(ag, 0)
}
}
id := inst.agMap[ag]
p := inst.ags[id]
err := p.AddAttribute(a)
if err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"inst",
"*",
"DenseInstances",
")",
"realiseAttributeGroups",
"(",
")",
"error",
"{",
"for",
"a",
":=",
"range",
"inst",
".",
"tmpAttrAgMap",
"{",
"// Generate a default AttributeGroup name",
"ag",
":=",
"inst",
".",
"tmpAttrAgMap",
"[",
"a",
"]",
... | //
// Allocation functions
//
// realiseAttributeGroups decides which Attributes are going
// to be stored in which groups | [
"Allocation",
"functions",
"realiseAttributeGroups",
"decides",
"which",
"Attributes",
"are",
"going",
"to",
"be",
"stored",
"in",
"which",
"groups"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L349-L386 |
164,755 | sjwhitworth/golearn | base/dense.go | MapOverRows | func (inst *DenseInstances) MapOverRows(asv []AttributeSpec, mapFunc func([][]byte, int) (bool, error)) error {
rowBuf := make([][]byte, len(asv))
for i := 0; i < inst.maxRow; i++ {
for j, as := range asv {
p := inst.ags[as.pond]
rowBuf[j] = p.get(as.position, i)
}
ok, err := mapFunc(rowBuf, i)
if err != nil {
return err
}
if !ok {
break
}
}
return nil
} | go | func (inst *DenseInstances) MapOverRows(asv []AttributeSpec, mapFunc func([][]byte, int) (bool, error)) error {
rowBuf := make([][]byte, len(asv))
for i := 0; i < inst.maxRow; i++ {
for j, as := range asv {
p := inst.ags[as.pond]
rowBuf[j] = p.get(as.position, i)
}
ok, err := mapFunc(rowBuf, i)
if err != nil {
return err
}
if !ok {
break
}
}
return nil
} | [
"func",
"(",
"inst",
"*",
"DenseInstances",
")",
"MapOverRows",
"(",
"asv",
"[",
"]",
"AttributeSpec",
",",
"mapFunc",
"func",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"int",
")",
"(",
"bool",
",",
"error",
")",
")",
"error",
"{",
"rowBuf",
":=",
"mak... | // MapOverRows passes each row map into a function.
// First argument is a list of AttributeSpec in the order
// they're needed in for the function. The second is the function
// to call on each row. | [
"MapOverRows",
"passes",
"each",
"row",
"map",
"into",
"a",
"function",
".",
"First",
"argument",
"is",
"a",
"list",
"of",
"AttributeSpec",
"in",
"the",
"order",
"they",
"re",
"needed",
"in",
"for",
"the",
"function",
".",
"The",
"second",
"is",
"the",
"... | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L460-L476 |
164,756 | sjwhitworth/golearn | base/dense.go | Size | func (inst *DenseInstances) Size() (int, int) {
return len(inst.AllAttributes()), inst.maxRow
} | go | func (inst *DenseInstances) Size() (int, int) {
return len(inst.AllAttributes()), inst.maxRow
} | [
"func",
"(",
"inst",
"*",
"DenseInstances",
")",
"Size",
"(",
")",
"(",
"int",
",",
"int",
")",
"{",
"return",
"len",
"(",
"inst",
".",
"AllAttributes",
"(",
")",
")",
",",
"inst",
".",
"maxRow",
"\n",
"}"
] | // Size returns the number of Attributes as the first return value
// and the maximum allocated row as the second value. | [
"Size",
"returns",
"the",
"number",
"of",
"Attributes",
"as",
"the",
"first",
"return",
"value",
"and",
"the",
"maximum",
"allocated",
"row",
"as",
"the",
"second",
"value",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L480-L482 |
164,757 | sjwhitworth/golearn | base/dense.go | swapRows | func (inst *DenseInstances) swapRows(i, j int) {
as := ResolveAllAttributes(inst)
for _, a := range as {
v1 := inst.Get(a, i)
v2 := inst.Get(a, j)
v3 := make([]byte, len(v2))
copy(v3, v2)
inst.Set(a, j, v1)
inst.Set(a, i, v3)
}
} | go | func (inst *DenseInstances) swapRows(i, j int) {
as := ResolveAllAttributes(inst)
for _, a := range as {
v1 := inst.Get(a, i)
v2 := inst.Get(a, j)
v3 := make([]byte, len(v2))
copy(v3, v2)
inst.Set(a, j, v1)
inst.Set(a, i, v3)
}
} | [
"func",
"(",
"inst",
"*",
"DenseInstances",
")",
"swapRows",
"(",
"i",
",",
"j",
"int",
")",
"{",
"as",
":=",
"ResolveAllAttributes",
"(",
"inst",
")",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"as",
"{",
"v1",
":=",
"inst",
".",
"Get",
"(",
"a"... | // swapRows swaps over rows i and j | [
"swapRows",
"swaps",
"over",
"rows",
"i",
"and",
"j"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L485-L495 |
164,758 | sjwhitworth/golearn | base/dense.go | String | func (inst *DenseInstances) String() string {
var buffer bytes.Buffer
// Get all Attribute information
as := ResolveAllAttributes(inst)
// Print header
cols, rows := inst.Size()
buffer.WriteString("Instances with ")
buffer.WriteString(fmt.Sprintf("%d row(s) ", rows))
buffer.WriteString(fmt.Sprintf("%d attribute(s)\n", cols))
buffer.WriteString(fmt.Sprintf("Attributes: \n"))
for _, a := range as {
prefix := "\t"
if inst.classAttrs[a] {
prefix = "*\t"
}
buffer.WriteString(fmt.Sprintf("%s%s\n", prefix, a.attr))
}
buffer.WriteString("\nData:\n")
maxRows := 30
if rows < maxRows {
maxRows = rows
}
for i := 0; i < maxRows; i++ {
buffer.WriteString("\t")
for _, a := range as {
val := inst.Get(a, i)
buffer.WriteString(fmt.Sprintf("%s ", a.attr.GetStringFromSysVal(val)))
}
buffer.WriteString("\n")
}
missingRows := rows - maxRows
if missingRows != 0 {
buffer.WriteString(fmt.Sprintf("\t...\n%d row(s) undisplayed", missingRows))
} else {
buffer.WriteString("All rows displayed")
}
return buffer.String()
} | go | func (inst *DenseInstances) String() string {
var buffer bytes.Buffer
// Get all Attribute information
as := ResolveAllAttributes(inst)
// Print header
cols, rows := inst.Size()
buffer.WriteString("Instances with ")
buffer.WriteString(fmt.Sprintf("%d row(s) ", rows))
buffer.WriteString(fmt.Sprintf("%d attribute(s)\n", cols))
buffer.WriteString(fmt.Sprintf("Attributes: \n"))
for _, a := range as {
prefix := "\t"
if inst.classAttrs[a] {
prefix = "*\t"
}
buffer.WriteString(fmt.Sprintf("%s%s\n", prefix, a.attr))
}
buffer.WriteString("\nData:\n")
maxRows := 30
if rows < maxRows {
maxRows = rows
}
for i := 0; i < maxRows; i++ {
buffer.WriteString("\t")
for _, a := range as {
val := inst.Get(a, i)
buffer.WriteString(fmt.Sprintf("%s ", a.attr.GetStringFromSysVal(val)))
}
buffer.WriteString("\n")
}
missingRows := rows - maxRows
if missingRows != 0 {
buffer.WriteString(fmt.Sprintf("\t...\n%d row(s) undisplayed", missingRows))
} else {
buffer.WriteString("All rows displayed")
}
return buffer.String()
} | [
"func",
"(",
"inst",
"*",
"DenseInstances",
")",
"String",
"(",
")",
"string",
"{",
"var",
"buffer",
"bytes",
".",
"Buffer",
"\n\n",
"// Get all Attribute information",
"as",
":=",
"ResolveAllAttributes",
"(",
"inst",
")",
"\n\n",
"// Print header",
"cols",
",",... | // String returns a human-readable summary of this dataset. | [
"String",
"returns",
"a",
"human",
"-",
"readable",
"summary",
"of",
"this",
"dataset",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/dense.go#L498-L542 |
164,759 | sjwhitworth/golearn | filters/float.go | NewFloatConvertFilter | func NewFloatConvertFilter() *FloatConvertFilter {
ret := &FloatConvertFilter{
make([]base.Attribute, 0),
make([]base.FilteredAttribute, 0),
make(map[base.Attribute]bool),
make(map[base.Attribute]map[uint64]base.Attribute),
}
return ret
} | go | func NewFloatConvertFilter() *FloatConvertFilter {
ret := &FloatConvertFilter{
make([]base.Attribute, 0),
make([]base.FilteredAttribute, 0),
make(map[base.Attribute]bool),
make(map[base.Attribute]map[uint64]base.Attribute),
}
return ret
} | [
"func",
"NewFloatConvertFilter",
"(",
")",
"*",
"FloatConvertFilter",
"{",
"ret",
":=",
"&",
"FloatConvertFilter",
"{",
"make",
"(",
"[",
"]",
"base",
".",
"Attribute",
",",
"0",
")",
",",
"make",
"(",
"[",
"]",
"base",
".",
"FilteredAttribute",
",",
"0"... | // NewFloatConvertFilter creates a blank FloatConvertFilter | [
"NewFloatConvertFilter",
"creates",
"a",
"blank",
"FloatConvertFilter"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/filters/float.go#L24-L32 |
164,760 | sjwhitworth/golearn | base/float.go | MarshalJSON | func (f *FloatAttribute) MarshalJSON() ([]byte, error) {
return json.Marshal(map[string]interface{}{
"type": "float",
"name": f.Name,
"attr": map[string]interface{}{
"precision": f.Precision,
},
})
} | go | func (f *FloatAttribute) MarshalJSON() ([]byte, error) {
return json.Marshal(map[string]interface{}{
"type": "float",
"name": f.Name,
"attr": map[string]interface{}{
"precision": f.Precision,
},
})
} | [
"func",
"(",
"f",
"*",
"FloatAttribute",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"json",
".",
"Marshal",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
... | // MarshalJSON returns a JSON representation of this Attribute
// for serialisation. | [
"MarshalJSON",
"returns",
"a",
"JSON",
"representation",
"of",
"this",
"Attribute",
"for",
"serialisation",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/float.go#L18-L26 |
164,761 | sjwhitworth/golearn | base/float.go | UnmarshalJSON | func (f *FloatAttribute) UnmarshalJSON(data []byte) error {
var d map[string]interface{}
err := json.Unmarshal(data, &d)
if err != nil {
return err
}
if precision, ok := d["precision"]; ok {
f.Precision = int(precision.(float64))
return nil
}
return fmt.Errorf("Precision must be specified")
} | go | func (f *FloatAttribute) UnmarshalJSON(data []byte) error {
var d map[string]interface{}
err := json.Unmarshal(data, &d)
if err != nil {
return err
}
if precision, ok := d["precision"]; ok {
f.Precision = int(precision.(float64))
return nil
}
return fmt.Errorf("Precision must be specified")
} | [
"func",
"(",
"f",
"*",
"FloatAttribute",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"d",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"d",
... | // UnmarshalJSON reads a JSON representation of this Attribute. | [
"UnmarshalJSON",
"reads",
"a",
"JSON",
"representation",
"of",
"this",
"Attribute",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/float.go#L29-L40 |
164,762 | sjwhitworth/golearn | base/float.go | Equals | func (Attr *FloatAttribute) Equals(other Attribute) bool {
// Check whether this FloatAttribute is equal to another
_, ok := other.(*FloatAttribute)
if !ok {
// Not the same type, so can't be equal
return false
}
if Attr.GetName() != other.GetName() {
return false
}
return true
} | go | func (Attr *FloatAttribute) Equals(other Attribute) bool {
// Check whether this FloatAttribute is equal to another
_, ok := other.(*FloatAttribute)
if !ok {
// Not the same type, so can't be equal
return false
}
if Attr.GetName() != other.GetName() {
return false
}
return true
} | [
"func",
"(",
"Attr",
"*",
"FloatAttribute",
")",
"Equals",
"(",
"other",
"Attribute",
")",
"bool",
"{",
"// Check whether this FloatAttribute is equal to another",
"_",
",",
"ok",
":=",
"other",
".",
"(",
"*",
"FloatAttribute",
")",
"\n",
"if",
"!",
"ok",
"{",... | // Equals tests a FloatAttribute for equality with another Attribute.
//
// Returns false if the other Attribute has a different name
// or if the other Attribute is not a FloatAttribute. | [
"Equals",
"tests",
"a",
"FloatAttribute",
"for",
"equality",
"with",
"another",
"Attribute",
".",
"Returns",
"false",
"if",
"the",
"other",
"Attribute",
"has",
"a",
"different",
"name",
"or",
"if",
"the",
"other",
"Attribute",
"is",
"not",
"a",
"FloatAttribute... | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/float.go#L59-L70 |
164,763 | sjwhitworth/golearn | base/float.go | CheckSysValFromString | func (Attr *FloatAttribute) CheckSysValFromString(rawVal string) ([]byte, error) {
f, err := strconv.ParseFloat(rawVal, 64)
if err != nil {
return nil, err
}
ret := PackFloatToBytes(f)
return ret, nil
} | go | func (Attr *FloatAttribute) CheckSysValFromString(rawVal string) ([]byte, error) {
f, err := strconv.ParseFloat(rawVal, 64)
if err != nil {
return nil, err
}
ret := PackFloatToBytes(f)
return ret, nil
} | [
"func",
"(",
"Attr",
"*",
"FloatAttribute",
")",
"CheckSysValFromString",
"(",
"rawVal",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"strconv",
".",
"ParseFloat",
"(",
"rawVal",
",",
"64",
")",
"\n",
"if",
"er... | // CheckSysValFromString confirms whether a given rawVal can
// be converted into a valid system representation. If it can't,
// the returned value is nil. | [
"CheckSysValFromString",
"confirms",
"whether",
"a",
"given",
"rawVal",
"can",
"be",
"converted",
"into",
"a",
"valid",
"system",
"representation",
".",
"If",
"it",
"can",
"t",
"the",
"returned",
"value",
"is",
"nil",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/float.go#L96-L104 |
164,764 | sjwhitworth/golearn | base/float.go | GetStringFromSysVal | func (Attr *FloatAttribute) GetStringFromSysVal(rawVal []byte) string {
f := UnpackBytesToFloat(rawVal)
formatString := fmt.Sprintf("%%.%df", Attr.Precision)
return fmt.Sprintf(formatString, f)
} | go | func (Attr *FloatAttribute) GetStringFromSysVal(rawVal []byte) string {
f := UnpackBytesToFloat(rawVal)
formatString := fmt.Sprintf("%%.%df", Attr.Precision)
return fmt.Sprintf(formatString, f)
} | [
"func",
"(",
"Attr",
"*",
"FloatAttribute",
")",
"GetStringFromSysVal",
"(",
"rawVal",
"[",
"]",
"byte",
")",
"string",
"{",
"f",
":=",
"UnpackBytesToFloat",
"(",
"rawVal",
")",
"\n",
"formatString",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"At... | // GetStringFromSysVal converts a given system value to to a string with two decimal
// places of precision. | [
"GetStringFromSysVal",
"converts",
"a",
"given",
"system",
"value",
"to",
"to",
"a",
"string",
"with",
"two",
"decimal",
"places",
"of",
"precision",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/float.go#L126-L130 |
164,765 | sjwhitworth/golearn | neural/network.go | NewNetwork | func NewNetwork(size int, input int, f NeuralFunction) *Network {
ret := new(Network)
ret.weights = mat.NewDense(size, size, make([]float64, size*size))
ret.biases = make([]float64, size)
ret.funcs = make([]NeuralFunction, size)
ret.size = size
ret.input = input
for i := range ret.funcs {
ret.funcs[i] = f
}
for i := 0; i < input; i++ {
ret.funcs[i] = Linear
ret.SetWeight(i+1, i+1, 1.0)
}
return ret
} | go | func NewNetwork(size int, input int, f NeuralFunction) *Network {
ret := new(Network)
ret.weights = mat.NewDense(size, size, make([]float64, size*size))
ret.biases = make([]float64, size)
ret.funcs = make([]NeuralFunction, size)
ret.size = size
ret.input = input
for i := range ret.funcs {
ret.funcs[i] = f
}
for i := 0; i < input; i++ {
ret.funcs[i] = Linear
ret.SetWeight(i+1, i+1, 1.0)
}
return ret
} | [
"func",
"NewNetwork",
"(",
"size",
"int",
",",
"input",
"int",
",",
"f",
"NeuralFunction",
")",
"*",
"Network",
"{",
"ret",
":=",
"new",
"(",
"Network",
")",
"\n",
"ret",
".",
"weights",
"=",
"mat",
".",
"NewDense",
"(",
"size",
",",
"size",
",",
"... | // NewNetwork creates a new Network containing size neurons,
// with a certain number dedicated to input, and a pre-defined
// neural function applied to the rest.
//
// Input nodes are set to have a Linear NeuralFunction and are
// connected to themselves for propagation. | [
"NewNetwork",
"creates",
"a",
"new",
"Network",
"containing",
"size",
"neurons",
"with",
"a",
"certain",
"number",
"dedicated",
"to",
"input",
"and",
"a",
"pre",
"-",
"defined",
"neural",
"function",
"applied",
"to",
"the",
"rest",
".",
"Input",
"nodes",
"ar... | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/neural/network.go#L28-L43 |
164,766 | sjwhitworth/golearn | neural/network.go | String | func (n *Network) String() string {
var buf bytes.Buffer
var biases bytes.Buffer
for i := 0; i < n.size; i++ {
for j := 0; j < n.size; j++ {
v := n.weights.At(j, i)
if math.Abs(v) > 0 {
buf.WriteString(fmt.Sprintf("\t(%d %d %.2f)\n", i+1, j+1, v))
}
}
}
for _, v := range n.biases {
biases.WriteString(fmt.Sprintf(" %.2f", v))
}
return fmt.Sprintf("Network(%d, %s, %s)", n.size, biases.String(), buf.String())
} | go | func (n *Network) String() string {
var buf bytes.Buffer
var biases bytes.Buffer
for i := 0; i < n.size; i++ {
for j := 0; j < n.size; j++ {
v := n.weights.At(j, i)
if math.Abs(v) > 0 {
buf.WriteString(fmt.Sprintf("\t(%d %d %.2f)\n", i+1, j+1, v))
}
}
}
for _, v := range n.biases {
biases.WriteString(fmt.Sprintf(" %.2f", v))
}
return fmt.Sprintf("Network(%d, %s, %s)", n.size, biases.String(), buf.String())
} | [
"func",
"(",
"n",
"*",
"Network",
")",
"String",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"var",
"biases",
"bytes",
".",
"Buffer",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
".",
"size",
";",
"i",
"++",
"{",
... | // String gets a human-readable representation of this network. | [
"String",
"gets",
"a",
"human",
"-",
"readable",
"representation",
"of",
"this",
"network",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/neural/network.go#L46-L64 |
164,767 | sjwhitworth/golearn | meta/bagging.go | generateTrainingAttrs | func (b *BaggedModel) generateTrainingAttrs(model int, from base.FixedDataGrid) []base.Attribute {
ret := make([]base.Attribute, 0)
attrs := base.NonClassAttributes(from)
if b.RandomFeatures == 0 {
ret = attrs
} else {
for {
if len(ret) >= b.RandomFeatures {
break
}
attrIndex := rand.Intn(len(attrs))
attr := attrs[attrIndex]
matched := false
for _, a := range ret {
if a.Equals(attr) {
matched = true
break
}
}
if !matched {
ret = append(ret, attr)
}
}
}
for _, a := range from.AllClassAttributes() {
ret = append(ret, a)
}
b.lock.Lock()
b.selectedAttributes[model] = ret
b.lock.Unlock()
return ret
} | go | func (b *BaggedModel) generateTrainingAttrs(model int, from base.FixedDataGrid) []base.Attribute {
ret := make([]base.Attribute, 0)
attrs := base.NonClassAttributes(from)
if b.RandomFeatures == 0 {
ret = attrs
} else {
for {
if len(ret) >= b.RandomFeatures {
break
}
attrIndex := rand.Intn(len(attrs))
attr := attrs[attrIndex]
matched := false
for _, a := range ret {
if a.Equals(attr) {
matched = true
break
}
}
if !matched {
ret = append(ret, attr)
}
}
}
for _, a := range from.AllClassAttributes() {
ret = append(ret, a)
}
b.lock.Lock()
b.selectedAttributes[model] = ret
b.lock.Unlock()
return ret
} | [
"func",
"(",
"b",
"*",
"BaggedModel",
")",
"generateTrainingAttrs",
"(",
"model",
"int",
",",
"from",
"base",
".",
"FixedDataGrid",
")",
"[",
"]",
"base",
".",
"Attribute",
"{",
"ret",
":=",
"make",
"(",
"[",
"]",
"base",
".",
"Attribute",
",",
"0",
... | // generateTrainingAttrs selects RandomFeatures number of base.Attributes from
// the provided base.Instances. | [
"generateTrainingAttrs",
"selects",
"RandomFeatures",
"number",
"of",
"base",
".",
"Attributes",
"from",
"the",
"provided",
"base",
".",
"Instances",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/meta/bagging.go#L25-L56 |
164,768 | sjwhitworth/golearn | meta/bagging.go | generatePredictionInstances | func (b *BaggedModel) generatePredictionInstances(model int, from base.FixedDataGrid) base.FixedDataGrid {
selected := b.selectedAttributes[model]
return base.NewInstancesViewFromAttrs(from, selected)
} | go | func (b *BaggedModel) generatePredictionInstances(model int, from base.FixedDataGrid) base.FixedDataGrid {
selected := b.selectedAttributes[model]
return base.NewInstancesViewFromAttrs(from, selected)
} | [
"func",
"(",
"b",
"*",
"BaggedModel",
")",
"generatePredictionInstances",
"(",
"model",
"int",
",",
"from",
"base",
".",
"FixedDataGrid",
")",
"base",
".",
"FixedDataGrid",
"{",
"selected",
":=",
"b",
".",
"selectedAttributes",
"[",
"model",
"]",
"\n",
"retu... | // generatePredictionInstances returns a modified version of the
// requested base.Instances with only the base.Attributes selected
// for training the model. | [
"generatePredictionInstances",
"returns",
"a",
"modified",
"version",
"of",
"the",
"requested",
"base",
".",
"Instances",
"with",
"only",
"the",
"base",
".",
"Attributes",
"selected",
"for",
"training",
"the",
"model",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/meta/bagging.go#L61-L64 |
164,769 | sjwhitworth/golearn | meta/bagging.go | generateTrainingInstances | func (b *BaggedModel) generateTrainingInstances(model int, from base.FixedDataGrid) base.FixedDataGrid {
_, rows := from.Size()
insts := base.SampleWithReplacement(from, rows)
selected := b.generateTrainingAttrs(model, from)
return base.NewInstancesViewFromAttrs(insts, selected)
} | go | func (b *BaggedModel) generateTrainingInstances(model int, from base.FixedDataGrid) base.FixedDataGrid {
_, rows := from.Size()
insts := base.SampleWithReplacement(from, rows)
selected := b.generateTrainingAttrs(model, from)
return base.NewInstancesViewFromAttrs(insts, selected)
} | [
"func",
"(",
"b",
"*",
"BaggedModel",
")",
"generateTrainingInstances",
"(",
"model",
"int",
",",
"from",
"base",
".",
"FixedDataGrid",
")",
"base",
".",
"FixedDataGrid",
"{",
"_",
",",
"rows",
":=",
"from",
".",
"Size",
"(",
")",
"\n",
"insts",
":=",
... | // generateTrainingInstances generates RandomFeatures number of
// attributes and returns a modified version of base.Instances
// for training the model | [
"generateTrainingInstances",
"generates",
"RandomFeatures",
"number",
"of",
"attributes",
"and",
"returns",
"a",
"modified",
"version",
"of",
"base",
".",
"Instances",
"for",
"training",
"the",
"model"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/meta/bagging.go#L69-L74 |
164,770 | sjwhitworth/golearn | meta/bagging.go | AddModel | func (b *BaggedModel) AddModel(m base.Classifier) {
b.Models = append(b.Models, m)
} | go | func (b *BaggedModel) AddModel(m base.Classifier) {
b.Models = append(b.Models, m)
} | [
"func",
"(",
"b",
"*",
"BaggedModel",
")",
"AddModel",
"(",
"m",
"base",
".",
"Classifier",
")",
"{",
"b",
".",
"Models",
"=",
"append",
"(",
"b",
".",
"Models",
",",
"m",
")",
"\n",
"}"
] | // AddModel adds a base.Classifier to the current model | [
"AddModel",
"adds",
"a",
"base",
".",
"Classifier",
"to",
"the",
"current",
"model"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/meta/bagging.go#L77-L79 |
164,771 | sjwhitworth/golearn | meta/bagging.go | Fit | func (b *BaggedModel) Fit(from base.FixedDataGrid) {
var wait sync.WaitGroup
b.selectedAttributes = make(map[int][]base.Attribute)
for i, m := range b.Models {
wait.Add(1)
go func(c base.Classifier, f base.FixedDataGrid, model int) {
l := b.generateTrainingInstances(model, f)
c.Fit(l)
wait.Done()
}(m, from, i)
}
wait.Wait()
b.fitOn = base.NewStructuralCopy(from)
} | go | func (b *BaggedModel) Fit(from base.FixedDataGrid) {
var wait sync.WaitGroup
b.selectedAttributes = make(map[int][]base.Attribute)
for i, m := range b.Models {
wait.Add(1)
go func(c base.Classifier, f base.FixedDataGrid, model int) {
l := b.generateTrainingInstances(model, f)
c.Fit(l)
wait.Done()
}(m, from, i)
}
wait.Wait()
b.fitOn = base.NewStructuralCopy(from)
} | [
"func",
"(",
"b",
"*",
"BaggedModel",
")",
"Fit",
"(",
"from",
"base",
".",
"FixedDataGrid",
")",
"{",
"var",
"wait",
"sync",
".",
"WaitGroup",
"\n",
"b",
".",
"selectedAttributes",
"=",
"make",
"(",
"map",
"[",
"int",
"]",
"[",
"]",
"base",
".",
"... | // Fit generates and trains each model on a randomised subset of
// Instances. | [
"Fit",
"generates",
"and",
"trains",
"each",
"model",
"on",
"a",
"randomised",
"subset",
"of",
"Instances",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/meta/bagging.go#L83-L96 |
164,772 | sjwhitworth/golearn | meta/bagging.go | String | func (b *BaggedModel) String() string {
children := make([]string, 0)
for i, m := range b.Models {
children = append(children, fmt.Sprintf("%d: %s", i, m))
}
return fmt.Sprintf("BaggedModel(\n%s)", strings.Join(children, "\n\t"))
} | go | func (b *BaggedModel) String() string {
children := make([]string, 0)
for i, m := range b.Models {
children = append(children, fmt.Sprintf("%d: %s", i, m))
}
return fmt.Sprintf("BaggedModel(\n%s)", strings.Join(children, "\n\t"))
} | [
"func",
"(",
"b",
"*",
"BaggedModel",
")",
"String",
"(",
")",
"string",
"{",
"children",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n",
"for",
"i",
",",
"m",
":=",
"range",
"b",
".",
"Models",
"{",
"children",
"=",
"append",
"(",
... | // String returns a human-readable representation of the
// BaggedModel and everything it contains | [
"String",
"returns",
"a",
"human",
"-",
"readable",
"representation",
"of",
"the",
"BaggedModel",
"and",
"everything",
"it",
"contains"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/meta/bagging.go#L184-L190 |
164,773 | sjwhitworth/golearn | metrics/pairwise/euclidean.go | InnerProduct | func (e *Euclidean) InnerProduct(vectorX *mat.Dense, vectorY *mat.Dense) float64 {
subVector := mat.NewDense(1, 1, nil)
subVector.Reset()
subVector.MulElem(vectorX, vectorY)
result := mat.Sum(subVector)
return result
} | go | func (e *Euclidean) InnerProduct(vectorX *mat.Dense, vectorY *mat.Dense) float64 {
subVector := mat.NewDense(1, 1, nil)
subVector.Reset()
subVector.MulElem(vectorX, vectorY)
result := mat.Sum(subVector)
return result
} | [
"func",
"(",
"e",
"*",
"Euclidean",
")",
"InnerProduct",
"(",
"vectorX",
"*",
"mat",
".",
"Dense",
",",
"vectorY",
"*",
"mat",
".",
"Dense",
")",
"float64",
"{",
"subVector",
":=",
"mat",
".",
"NewDense",
"(",
"1",
",",
"1",
",",
"nil",
")",
"\n",
... | // InnerProduct computes a Eucledian inner product. | [
"InnerProduct",
"computes",
"a",
"Eucledian",
"inner",
"product",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/metrics/pairwise/euclidean.go#L16-L23 |
164,774 | sjwhitworth/golearn | base/filewrapper.go | ParseCSVGetRows | func ParseCSVGetRows(filepath string) (int, error) {
f, err := os.Open(filepath)
if err != nil {
return 0, err
}
defer f.Close()
return ParseCSVGetRowsFromReader(f)
} | go | func ParseCSVGetRows(filepath string) (int, error) {
f, err := os.Open(filepath)
if err != nil {
return 0, err
}
defer f.Close()
return ParseCSVGetRowsFromReader(f)
} | [
"func",
"ParseCSVGetRows",
"(",
"filepath",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filepath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"defer... | // ParseCSVGetRows returns the number of rows in a given file. | [
"ParseCSVGetRows",
"returns",
"the",
"number",
"of",
"rows",
"in",
"a",
"given",
"file",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filewrapper.go#L8-L16 |
164,775 | sjwhitworth/golearn | base/filewrapper.go | ParseCSVEstimateFilePrecision | func ParseCSVEstimateFilePrecision(filepath string) (int, error) {
// Open the source file
f, err := os.Open(filepath)
if err != nil {
return 0, err
}
defer f.Close()
return ParseCSVEstimateFilePrecisionFromReader(f)
} | go | func ParseCSVEstimateFilePrecision(filepath string) (int, error) {
// Open the source file
f, err := os.Open(filepath)
if err != nil {
return 0, err
}
defer f.Close()
return ParseCSVEstimateFilePrecisionFromReader(f)
} | [
"func",
"ParseCSVEstimateFilePrecision",
"(",
"filepath",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"// Open the source file",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filepath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",... | // ParseCSVEstimateFilePrecision determines what the maximum number of
// digits occuring anywhere after the decimal point within the file. | [
"ParseCSVEstimateFilePrecision",
"determines",
"what",
"the",
"maximum",
"number",
"of",
"digits",
"occuring",
"anywhere",
"after",
"the",
"decimal",
"point",
"within",
"the",
"file",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filewrapper.go#L20-L29 |
164,776 | sjwhitworth/golearn | base/filewrapper.go | ParseCSVGetAttributes | func ParseCSVGetAttributes(filepath string, hasHeaders bool) []Attribute {
f, err := os.Open(filepath)
if err != nil {
panic(err)
}
defer f.Close()
return ParseCSVGetAttributesFromReader(f, hasHeaders)
} | go | func ParseCSVGetAttributes(filepath string, hasHeaders bool) []Attribute {
f, err := os.Open(filepath)
if err != nil {
panic(err)
}
defer f.Close()
return ParseCSVGetAttributesFromReader(f, hasHeaders)
} | [
"func",
"ParseCSVGetAttributes",
"(",
"filepath",
"string",
",",
"hasHeaders",
"bool",
")",
"[",
"]",
"Attribute",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filepath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n... | // ParseCSVGetAttributes returns an ordered slice of appropriate-ly typed
// and named Attributes. | [
"ParseCSVGetAttributes",
"returns",
"an",
"ordered",
"slice",
"of",
"appropriate",
"-",
"ly",
"typed",
"and",
"named",
"Attributes",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filewrapper.go#L33-L41 |
164,777 | sjwhitworth/golearn | base/filewrapper.go | ParseCSVSniffAttributeNames | func ParseCSVSniffAttributeNames(filepath string, hasHeaders bool) []string {
f, err := os.Open(filepath)
if err != nil {
panic(err)
}
defer f.Close()
return ParseCSVSniffAttributeNamesFromReader(f, hasHeaders)
} | go | func ParseCSVSniffAttributeNames(filepath string, hasHeaders bool) []string {
f, err := os.Open(filepath)
if err != nil {
panic(err)
}
defer f.Close()
return ParseCSVSniffAttributeNamesFromReader(f, hasHeaders)
} | [
"func",
"ParseCSVSniffAttributeNames",
"(",
"filepath",
"string",
",",
"hasHeaders",
"bool",
")",
"[",
"]",
"string",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filepath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
... | // ParseCSVSniffAttributeNames returns a slice containing the top row
// of a given CSV file, or placeholders if hasHeaders is false. | [
"ParseCSVSniffAttributeNames",
"returns",
"a",
"slice",
"containing",
"the",
"top",
"row",
"of",
"a",
"given",
"CSV",
"file",
"or",
"placeholders",
"if",
"hasHeaders",
"is",
"false",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filewrapper.go#L45-L53 |
164,778 | sjwhitworth/golearn | base/filewrapper.go | ParseCSVSniffAttributeTypes | func ParseCSVSniffAttributeTypes(filepath string, hasHeaders bool) []Attribute {
// Open file
f, err := os.Open(filepath)
if err != nil {
panic(err)
}
defer f.Close()
return ParseCSVSniffAttributeTypesFromReader(f, hasHeaders)
} | go | func ParseCSVSniffAttributeTypes(filepath string, hasHeaders bool) []Attribute {
// Open file
f, err := os.Open(filepath)
if err != nil {
panic(err)
}
defer f.Close()
return ParseCSVSniffAttributeTypesFromReader(f, hasHeaders)
} | [
"func",
"ParseCSVSniffAttributeTypes",
"(",
"filepath",
"string",
",",
"hasHeaders",
"bool",
")",
"[",
"]",
"Attribute",
"{",
"// Open file",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filepath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(... | // ParseCSVSniffAttributeTypes returns a slice of appropriately-typed Attributes.
//
// The type of a given attribute is determined by looking at the first data row
// of the CSV. | [
"ParseCSVSniffAttributeTypes",
"returns",
"a",
"slice",
"of",
"appropriately",
"-",
"typed",
"Attributes",
".",
"The",
"type",
"of",
"a",
"given",
"attribute",
"is",
"determined",
"by",
"looking",
"at",
"the",
"first",
"data",
"row",
"of",
"the",
"CSV",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filewrapper.go#L59-L68 |
164,779 | sjwhitworth/golearn | base/filewrapper.go | ParseCSVToInstances | func ParseCSVToInstances(filepath string, hasHeaders bool) (instances *DenseInstances, err error) {
// Open the file
f, err := os.Open(filepath)
if err != nil {
return nil, err
}
defer f.Close()
return ParseCSVToInstancesFromReader(f, hasHeaders)
} | go | func ParseCSVToInstances(filepath string, hasHeaders bool) (instances *DenseInstances, err error) {
// Open the file
f, err := os.Open(filepath)
if err != nil {
return nil, err
}
defer f.Close()
return ParseCSVToInstancesFromReader(f, hasHeaders)
} | [
"func",
"ParseCSVToInstances",
"(",
"filepath",
"string",
",",
"hasHeaders",
"bool",
")",
"(",
"instances",
"*",
"DenseInstances",
",",
"err",
"error",
")",
"{",
"// Open the file",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filepath",
")",
"\n",
"if"... | // ParseCSVToInstances reads the CSV file given by filepath and returns
// the read Instances. | [
"ParseCSVToInstances",
"reads",
"the",
"CSV",
"file",
"given",
"by",
"filepath",
"and",
"returns",
"the",
"read",
"Instances",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filewrapper.go#L72-L81 |
164,780 | sjwhitworth/golearn | base/filewrapper.go | ParseCSVToTemplatedInstances | func ParseCSVToTemplatedInstances(filepath string, hasHeaders bool, template *DenseInstances) (instances *DenseInstances, err error) {
// Open the file
f, err := os.Open(filepath)
if err != nil {
return nil, err
}
defer f.Close()
return ParseCSVToTemplatedInstancesFromReader(f, hasHeaders, template)
} | go | func ParseCSVToTemplatedInstances(filepath string, hasHeaders bool, template *DenseInstances) (instances *DenseInstances, err error) {
// Open the file
f, err := os.Open(filepath)
if err != nil {
return nil, err
}
defer f.Close()
return ParseCSVToTemplatedInstancesFromReader(f, hasHeaders, template)
} | [
"func",
"ParseCSVToTemplatedInstances",
"(",
"filepath",
"string",
",",
"hasHeaders",
"bool",
",",
"template",
"*",
"DenseInstances",
")",
"(",
"instances",
"*",
"DenseInstances",
",",
"err",
"error",
")",
"{",
"// Open the file",
"f",
",",
"err",
":=",
"os",
... | // ParseCSVToInstancesTemplated reads the CSV file given by filepath and returns
// the read Instances, using another already read DenseInstances as a template. | [
"ParseCSVToInstancesTemplated",
"reads",
"the",
"CSV",
"file",
"given",
"by",
"filepath",
"and",
"returns",
"the",
"read",
"Instances",
"using",
"another",
"already",
"read",
"DenseInstances",
"as",
"a",
"template",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filewrapper.go#L85-L94 |
164,781 | sjwhitworth/golearn | base/filewrapper.go | ParseCSVToInstancesWithAttributeGroups | func ParseCSVToInstancesWithAttributeGroups(filepath string, attrGroups, classAttrGroups map[string]string, attrOverrides map[int]Attribute, hasHeaders bool) (instances *DenseInstances, err error) {
// Open file
f, err := os.Open(filepath)
if err != nil {
return nil, err
}
defer f.Close()
return ParseCSVToInstancesWithAttributeGroupsFromReader(f, attrGroups, classAttrGroups, attrOverrides, hasHeaders)
} | go | func ParseCSVToInstancesWithAttributeGroups(filepath string, attrGroups, classAttrGroups map[string]string, attrOverrides map[int]Attribute, hasHeaders bool) (instances *DenseInstances, err error) {
// Open file
f, err := os.Open(filepath)
if err != nil {
return nil, err
}
defer f.Close()
return ParseCSVToInstancesWithAttributeGroupsFromReader(f, attrGroups, classAttrGroups, attrOverrides, hasHeaders)
} | [
"func",
"ParseCSVToInstancesWithAttributeGroups",
"(",
"filepath",
"string",
",",
"attrGroups",
",",
"classAttrGroups",
"map",
"[",
"string",
"]",
"string",
",",
"attrOverrides",
"map",
"[",
"int",
"]",
"Attribute",
",",
"hasHeaders",
"bool",
")",
"(",
"instances"... | // ParseCSVToInstancesWithAttributeGroups reads the CSV file given by filepath,
// and returns the read DenseInstances, but also makes sure to group any Attributes
// specified in the first argument and also any class Attributes specified in the second | [
"ParseCSVToInstancesWithAttributeGroups",
"reads",
"the",
"CSV",
"file",
"given",
"by",
"filepath",
"and",
"returns",
"the",
"read",
"DenseInstances",
"but",
"also",
"makes",
"sure",
"to",
"group",
"any",
"Attributes",
"specified",
"in",
"the",
"first",
"argument",
... | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filewrapper.go#L99-L108 |
164,782 | sjwhitworth/golearn | naive/bernoulli_nb.go | NewBernoulliNBClassifier | func NewBernoulliNBClassifier() *BernoulliNBClassifier {
nb := BernoulliNBClassifier{}
nb.condProb = make(map[string][]float64)
nb.features = 0
nb.trainingInstances = 0
return &nb
} | go | func NewBernoulliNBClassifier() *BernoulliNBClassifier {
nb := BernoulliNBClassifier{}
nb.condProb = make(map[string][]float64)
nb.features = 0
nb.trainingInstances = 0
return &nb
} | [
"func",
"NewBernoulliNBClassifier",
"(",
")",
"*",
"BernoulliNBClassifier",
"{",
"nb",
":=",
"BernoulliNBClassifier",
"{",
"}",
"\n",
"nb",
".",
"condProb",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"float64",
")",
"\n",
"nb",
".",
"features",... | // Create a new Bernoulli Naive Bayes Classifier. The argument 'classes'
// is the number of possible labels in the classification task. | [
"Create",
"a",
"new",
"Bernoulli",
"Naive",
"Bayes",
"Classifier",
".",
"The",
"argument",
"classes",
"is",
"the",
"number",
"of",
"possible",
"labels",
"in",
"the",
"classification",
"task",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/naive/bernoulli_nb.go#L175-L181 |
164,783 | sjwhitworth/golearn | clustering/clustering.go | Invert | func (ref ClusterMap) Invert() (map[int]int, error) {
ret := make(map[int]int)
for c := range ref {
for _, p := range ref[c] {
if _, ok := ret[p]; ok {
return nil, fmt.Errorf("Not a valid cluster map (points appear in more than one cluster)")
} else {
ret[p] = c
}
}
}
return ret, nil
} | go | func (ref ClusterMap) Invert() (map[int]int, error) {
ret := make(map[int]int)
for c := range ref {
for _, p := range ref[c] {
if _, ok := ret[p]; ok {
return nil, fmt.Errorf("Not a valid cluster map (points appear in more than one cluster)")
} else {
ret[p] = c
}
}
}
return ret, nil
} | [
"func",
"(",
"ref",
"ClusterMap",
")",
"Invert",
"(",
")",
"(",
"map",
"[",
"int",
"]",
"int",
",",
"error",
")",
"{",
"ret",
":=",
"make",
"(",
"map",
"[",
"int",
"]",
"int",
")",
"\n",
"for",
"c",
":=",
"range",
"ref",
"{",
"for",
"_",
",",... | // Invert returns an alternative form of cluster map where the key represents the point
// index and the value represents the cluster index it's assigned to | [
"Invert",
"returns",
"an",
"alternative",
"form",
"of",
"cluster",
"map",
"where",
"the",
"key",
"represents",
"the",
"point",
"index",
"and",
"the",
"value",
"represents",
"the",
"cluster",
"index",
"it",
"s",
"assigned",
"to"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/clustering/clustering.go#L29-L41 |
164,784 | sjwhitworth/golearn | filters/disc.go | AddAttribute | func (d *AbstractDiscretizeFilter) AddAttribute(a base.Attribute) error {
if _, ok := a.(*base.FloatAttribute); !ok {
return fmt.Errorf("%s is not a FloatAttribute", a)
}
_, err := d.train.GetAttribute(a)
if err != nil {
return fmt.Errorf("invalid attribute")
}
d.attrs[a] = true
return nil
} | go | func (d *AbstractDiscretizeFilter) AddAttribute(a base.Attribute) error {
if _, ok := a.(*base.FloatAttribute); !ok {
return fmt.Errorf("%s is not a FloatAttribute", a)
}
_, err := d.train.GetAttribute(a)
if err != nil {
return fmt.Errorf("invalid attribute")
}
d.attrs[a] = true
return nil
} | [
"func",
"(",
"d",
"*",
"AbstractDiscretizeFilter",
")",
"AddAttribute",
"(",
"a",
"base",
".",
"Attribute",
")",
"error",
"{",
"if",
"_",
",",
"ok",
":=",
"a",
".",
"(",
"*",
"base",
".",
"FloatAttribute",
")",
";",
"!",
"ok",
"{",
"return",
"fmt",
... | // AddAttribute adds the AttributeSpec of the given attribute `a'
// to the AbstractFloatFilter for discretisation. | [
"AddAttribute",
"adds",
"the",
"AttributeSpec",
"of",
"the",
"given",
"attribute",
"a",
"to",
"the",
"AbstractFloatFilter",
"for",
"discretisation",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/filters/disc.go#L16-L26 |
164,785 | sjwhitworth/golearn | metrics/pairwise/manhattan.go | Distance | func (m *Manhattan) Distance(vectorX *mat.Dense, vectorY *mat.Dense) float64 {
r1, c1 := vectorX.Dims()
r2, c2 := vectorY.Dims()
if r1 != r2 || c1 != c2 {
panic(matrix.ErrShape)
}
result := .0
for i := 0; i < r1; i++ {
for j := 0; j < c1; j++ {
result += math.Abs(vectorX.At(i, j) - vectorY.At(i, j))
}
}
return result
} | go | func (m *Manhattan) Distance(vectorX *mat.Dense, vectorY *mat.Dense) float64 {
r1, c1 := vectorX.Dims()
r2, c2 := vectorY.Dims()
if r1 != r2 || c1 != c2 {
panic(matrix.ErrShape)
}
result := .0
for i := 0; i < r1; i++ {
for j := 0; j < c1; j++ {
result += math.Abs(vectorX.At(i, j) - vectorY.At(i, j))
}
}
return result
} | [
"func",
"(",
"m",
"*",
"Manhattan",
")",
"Distance",
"(",
"vectorX",
"*",
"mat",
".",
"Dense",
",",
"vectorY",
"*",
"mat",
".",
"Dense",
")",
"float64",
"{",
"r1",
",",
"c1",
":=",
"vectorX",
".",
"Dims",
"(",
")",
"\n",
"r2",
",",
"c2",
":=",
... | // Distance computes the Manhattan distance, also known as L1 distance.
// == the sum of the absolute values of elements. | [
"Distance",
"computes",
"the",
"Manhattan",
"distance",
"also",
"known",
"as",
"L1",
"distance",
".",
"==",
"the",
"sum",
"of",
"the",
"absolute",
"values",
"of",
"elements",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/metrics/pairwise/manhattan.go#L18-L33 |
164,786 | sjwhitworth/golearn | base/filtered.go | NewLazilyFilteredInstances | func NewLazilyFilteredInstances(src FixedDataGrid, f Filter) *LazilyFilteredInstances {
// Get the Attributes after filtering
attrs := f.GetAttributesAfterFiltering()
// Build a set of Attributes which have undergone filtering
unFilteredMap := make(map[Attribute]bool)
for _, a := range src.AllAttributes() {
unFilteredMap[a] = true
}
for _, a := range attrs {
unFilteredMap[a.Old] = false
}
// Create the return structure
ret := &LazilyFilteredInstances{
f,
src,
attrs,
make(map[Attribute]bool),
unFilteredMap,
}
// Transfer class Attributes
for _, a := range src.AllClassAttributes() {
ret.AddClassAttribute(a)
}
return ret
} | go | func NewLazilyFilteredInstances(src FixedDataGrid, f Filter) *LazilyFilteredInstances {
// Get the Attributes after filtering
attrs := f.GetAttributesAfterFiltering()
// Build a set of Attributes which have undergone filtering
unFilteredMap := make(map[Attribute]bool)
for _, a := range src.AllAttributes() {
unFilteredMap[a] = true
}
for _, a := range attrs {
unFilteredMap[a.Old] = false
}
// Create the return structure
ret := &LazilyFilteredInstances{
f,
src,
attrs,
make(map[Attribute]bool),
unFilteredMap,
}
// Transfer class Attributes
for _, a := range src.AllClassAttributes() {
ret.AddClassAttribute(a)
}
return ret
} | [
"func",
"NewLazilyFilteredInstances",
"(",
"src",
"FixedDataGrid",
",",
"f",
"Filter",
")",
"*",
"LazilyFilteredInstances",
"{",
"// Get the Attributes after filtering",
"attrs",
":=",
"f",
".",
"GetAttributesAfterFiltering",
"(",
")",
"\n\n",
"// Build a set of Attributes ... | // NewLazilyFitleredInstances returns a new FixedDataGrid after
// applying the given Filter to the Attributes it includes. Unfiltered
// Attributes are passed through without modification. | [
"NewLazilyFitleredInstances",
"returns",
"a",
"new",
"FixedDataGrid",
"after",
"applying",
"the",
"given",
"Filter",
"to",
"the",
"Attributes",
"it",
"includes",
".",
"Unfiltered",
"Attributes",
"are",
"passed",
"through",
"without",
"modification",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filtered.go#L24-L52 |
164,787 | sjwhitworth/golearn | base/filtered.go | GetAttribute | func (l *LazilyFilteredInstances) GetAttribute(target Attribute) (AttributeSpec, error) {
if l.unfilteredMap[target] {
return l.src.GetAttribute(target)
}
var ret AttributeSpec
ret.pond = -1
for i, a := range l.attrs {
if a.New.Equals(target) {
ret.position = i
ret.attr = target
return ret, nil
}
}
return ret, fmt.Errorf("Couldn't resolve %s", target)
} | go | func (l *LazilyFilteredInstances) GetAttribute(target Attribute) (AttributeSpec, error) {
if l.unfilteredMap[target] {
return l.src.GetAttribute(target)
}
var ret AttributeSpec
ret.pond = -1
for i, a := range l.attrs {
if a.New.Equals(target) {
ret.position = i
ret.attr = target
return ret, nil
}
}
return ret, fmt.Errorf("Couldn't resolve %s", target)
} | [
"func",
"(",
"l",
"*",
"LazilyFilteredInstances",
")",
"GetAttribute",
"(",
"target",
"Attribute",
")",
"(",
"AttributeSpec",
",",
"error",
")",
"{",
"if",
"l",
".",
"unfilteredMap",
"[",
"target",
"]",
"{",
"return",
"l",
".",
"src",
".",
"GetAttribute",
... | // GetAttribute returns an AttributeSpecification for a given Attribute | [
"GetAttribute",
"returns",
"an",
"AttributeSpecification",
"for",
"a",
"given",
"Attribute"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filtered.go#L55-L69 |
164,788 | sjwhitworth/golearn | base/filtered.go | AllAttributes | func (l *LazilyFilteredInstances) AllAttributes() []Attribute {
ret := make([]Attribute, 0)
for _, a := range l.src.AllAttributes() {
if l.unfilteredMap[a] {
ret = append(ret, a)
} else {
for _, b := range l.attrs {
if a.Equals(b.Old) {
ret = append(ret, b.New)
}
}
}
}
return ret
} | go | func (l *LazilyFilteredInstances) AllAttributes() []Attribute {
ret := make([]Attribute, 0)
for _, a := range l.src.AllAttributes() {
if l.unfilteredMap[a] {
ret = append(ret, a)
} else {
for _, b := range l.attrs {
if a.Equals(b.Old) {
ret = append(ret, b.New)
}
}
}
}
return ret
} | [
"func",
"(",
"l",
"*",
"LazilyFilteredInstances",
")",
"AllAttributes",
"(",
")",
"[",
"]",
"Attribute",
"{",
"ret",
":=",
"make",
"(",
"[",
"]",
"Attribute",
",",
"0",
")",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"l",
".",
"src",
".",
"AllAttri... | // AllAttributes returns every Attribute defined in the source datagrid,
// in addition to the revised Attributes created by the filter. | [
"AllAttributes",
"returns",
"every",
"Attribute",
"defined",
"in",
"the",
"source",
"datagrid",
"in",
"addition",
"to",
"the",
"revised",
"Attributes",
"created",
"by",
"the",
"filter",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filtered.go#L73-L87 |
164,789 | sjwhitworth/golearn | base/filtered.go | AllClassAttributes | func (l *LazilyFilteredInstances) AllClassAttributes() []Attribute {
ret := make([]Attribute, 0)
for a := range l.classAttrs {
if l.classAttrs[a] {
ret = append(ret, a)
}
}
return ret
} | go | func (l *LazilyFilteredInstances) AllClassAttributes() []Attribute {
ret := make([]Attribute, 0)
for a := range l.classAttrs {
if l.classAttrs[a] {
ret = append(ret, a)
}
}
return ret
} | [
"func",
"(",
"l",
"*",
"LazilyFilteredInstances",
")",
"AllClassAttributes",
"(",
")",
"[",
"]",
"Attribute",
"{",
"ret",
":=",
"make",
"(",
"[",
"]",
"Attribute",
",",
"0",
")",
"\n",
"for",
"a",
":=",
"range",
"l",
".",
"classAttrs",
"{",
"if",
"l"... | // AllClassAttributes returns details of all Attributes currently specified
// as being class Attributes.
//
// If applicable, the Attributes returned are those after modification
// by the Filter. | [
"AllClassAttributes",
"returns",
"details",
"of",
"all",
"Attributes",
"currently",
"specified",
"as",
"being",
"class",
"Attributes",
".",
"If",
"applicable",
"the",
"Attributes",
"returned",
"are",
"those",
"after",
"modification",
"by",
"the",
"Filter",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filtered.go#L130-L138 |
164,790 | sjwhitworth/golearn | base/filtered.go | Get | func (l *LazilyFilteredInstances) Get(as AttributeSpec, row int) []byte {
asOld, err := l.transformNewToOldAttribute(as)
if err != nil {
panic(fmt.Sprintf("Attribute %s could not be resolved. (Error: %s)", as.String(), err.Error()))
}
byteSeq := l.src.Get(asOld, row)
if l.unfilteredMap[as.attr] {
return byteSeq
}
newByteSeq := l.filter.Transform(asOld.attr, as.attr, byteSeq)
return newByteSeq
} | go | func (l *LazilyFilteredInstances) Get(as AttributeSpec, row int) []byte {
asOld, err := l.transformNewToOldAttribute(as)
if err != nil {
panic(fmt.Sprintf("Attribute %s could not be resolved. (Error: %s)", as.String(), err.Error()))
}
byteSeq := l.src.Get(asOld, row)
if l.unfilteredMap[as.attr] {
return byteSeq
}
newByteSeq := l.filter.Transform(asOld.attr, as.attr, byteSeq)
return newByteSeq
} | [
"func",
"(",
"l",
"*",
"LazilyFilteredInstances",
")",
"Get",
"(",
"as",
"AttributeSpec",
",",
"row",
"int",
")",
"[",
"]",
"byte",
"{",
"asOld",
",",
"err",
":=",
"l",
".",
"transformNewToOldAttribute",
"(",
"as",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // Get returns a transformed byte slice stored at a given AttributeSpec and row. | [
"Get",
"returns",
"a",
"transformed",
"byte",
"slice",
"stored",
"at",
"a",
"given",
"AttributeSpec",
"and",
"row",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filtered.go#L157-L168 |
164,791 | sjwhitworth/golearn | base/filtered.go | MapOverRows | func (l *LazilyFilteredInstances) MapOverRows(asv []AttributeSpec, mapFunc func([][]byte, int) (bool, error)) error {
// Have to transform each item of asv into an
// AttributeSpec in the original
oldAsv := make([]AttributeSpec, len(asv))
for i, a := range asv {
old, err := l.transformNewToOldAttribute(a)
if err != nil {
return fmt.Errorf("Couldn't fetch old Attribute: '%s'", a.String())
}
oldAsv[i] = old
}
// Then map over each row in the original
newRowBuf := make([][]byte, len(asv))
return l.src.MapOverRows(oldAsv, func(oldRow [][]byte, oldRowNo int) (bool, error) {
for i, b := range oldRow {
newField := l.filter.Transform(oldAsv[i].attr, asv[i].attr, b)
newRowBuf[i] = newField
}
return mapFunc(newRowBuf, oldRowNo)
})
} | go | func (l *LazilyFilteredInstances) MapOverRows(asv []AttributeSpec, mapFunc func([][]byte, int) (bool, error)) error {
// Have to transform each item of asv into an
// AttributeSpec in the original
oldAsv := make([]AttributeSpec, len(asv))
for i, a := range asv {
old, err := l.transformNewToOldAttribute(a)
if err != nil {
return fmt.Errorf("Couldn't fetch old Attribute: '%s'", a.String())
}
oldAsv[i] = old
}
// Then map over each row in the original
newRowBuf := make([][]byte, len(asv))
return l.src.MapOverRows(oldAsv, func(oldRow [][]byte, oldRowNo int) (bool, error) {
for i, b := range oldRow {
newField := l.filter.Transform(oldAsv[i].attr, asv[i].attr, b)
newRowBuf[i] = newField
}
return mapFunc(newRowBuf, oldRowNo)
})
} | [
"func",
"(",
"l",
"*",
"LazilyFilteredInstances",
")",
"MapOverRows",
"(",
"asv",
"[",
"]",
"AttributeSpec",
",",
"mapFunc",
"func",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"int",
")",
"(",
"bool",
",",
"error",
")",
")",
"error",
"{",
"// Have to transf... | // MapOverRows maps an iteration mapFunc over the bytes contained in the source
// FixedDataGrid, after modification by the filter. | [
"MapOverRows",
"maps",
"an",
"iteration",
"mapFunc",
"over",
"the",
"bytes",
"contained",
"in",
"the",
"source",
"FixedDataGrid",
"after",
"modification",
"by",
"the",
"filter",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filtered.go#L172-L194 |
164,792 | sjwhitworth/golearn | base/filtered.go | String | func (l *LazilyFilteredInstances) String() string {
var buffer bytes.Buffer
// Decide on rows to print
_, rows := l.Size()
maxRows := 5
if rows < maxRows {
maxRows = rows
}
// Get all Attribute information
as := ResolveAllAttributes(l)
// Print header
buffer.WriteString("Lazily filtered instances using ")
buffer.WriteString(fmt.Sprintf("%s\n", l.filter))
buffer.WriteString(fmt.Sprintf("Attributes: \n"))
for _, a := range as {
prefix := "\t"
if l.classAttrs[a.attr] {
prefix = "*\t"
}
buffer.WriteString(fmt.Sprintf("%s%s\n", prefix, a.attr))
}
buffer.WriteString("\nData:\n")
for i := 0; i < maxRows; i++ {
buffer.WriteString("\t")
for _, a := range as {
val := l.Get(a, i)
buffer.WriteString(fmt.Sprintf("%s ", a.attr.GetStringFromSysVal(val)))
}
buffer.WriteString("\n")
}
return buffer.String()
} | go | func (l *LazilyFilteredInstances) String() string {
var buffer bytes.Buffer
// Decide on rows to print
_, rows := l.Size()
maxRows := 5
if rows < maxRows {
maxRows = rows
}
// Get all Attribute information
as := ResolveAllAttributes(l)
// Print header
buffer.WriteString("Lazily filtered instances using ")
buffer.WriteString(fmt.Sprintf("%s\n", l.filter))
buffer.WriteString(fmt.Sprintf("Attributes: \n"))
for _, a := range as {
prefix := "\t"
if l.classAttrs[a.attr] {
prefix = "*\t"
}
buffer.WriteString(fmt.Sprintf("%s%s\n", prefix, a.attr))
}
buffer.WriteString("\nData:\n")
for i := 0; i < maxRows; i++ {
buffer.WriteString("\t")
for _, a := range as {
val := l.Get(a, i)
buffer.WriteString(fmt.Sprintf("%s ", a.attr.GetStringFromSysVal(val)))
}
buffer.WriteString("\n")
}
return buffer.String()
} | [
"func",
"(",
"l",
"*",
"LazilyFilteredInstances",
")",
"String",
"(",
")",
"string",
"{",
"var",
"buffer",
"bytes",
".",
"Buffer",
"\n\n",
"// Decide on rows to print",
"_",
",",
"rows",
":=",
"l",
".",
"Size",
"(",
")",
"\n",
"maxRows",
":=",
"5",
"\n",... | // String returns a human-readable summary of this FixedDataGrid
// after filtering. | [
"String",
"returns",
"a",
"human",
"-",
"readable",
"summary",
"of",
"this",
"FixedDataGrid",
"after",
"filtering",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/base/filtered.go#L225-L262 |
164,793 | sjwhitworth/golearn | trees/random.go | GenerateSplitRule | func (r *RandomTreeRuleGenerator) GenerateSplitRule(f base.FixedDataGrid) *DecisionTreeRule {
var consideredAttributes []base.Attribute
// First step is to generate the random attributes that we'll consider
allAttributes := base.AttributeDifferenceReferences(f.AllAttributes(), f.AllClassAttributes())
maximumAttribute := len(allAttributes)
attrCounter := 0
for {
if len(consideredAttributes) >= r.Attributes {
break
}
selectedAttrIndex := rand.Intn(maximumAttribute)
selectedAttribute := allAttributes[selectedAttrIndex]
matched := false
for _, a := range consideredAttributes {
if a.Equals(selectedAttribute) {
matched = true
break
}
}
if matched {
continue
}
consideredAttributes = append(consideredAttributes, selectedAttribute)
attrCounter++
}
return r.internalRule.GetSplitRuleFromSelection(consideredAttributes, f)
} | go | func (r *RandomTreeRuleGenerator) GenerateSplitRule(f base.FixedDataGrid) *DecisionTreeRule {
var consideredAttributes []base.Attribute
// First step is to generate the random attributes that we'll consider
allAttributes := base.AttributeDifferenceReferences(f.AllAttributes(), f.AllClassAttributes())
maximumAttribute := len(allAttributes)
attrCounter := 0
for {
if len(consideredAttributes) >= r.Attributes {
break
}
selectedAttrIndex := rand.Intn(maximumAttribute)
selectedAttribute := allAttributes[selectedAttrIndex]
matched := false
for _, a := range consideredAttributes {
if a.Equals(selectedAttribute) {
matched = true
break
}
}
if matched {
continue
}
consideredAttributes = append(consideredAttributes, selectedAttribute)
attrCounter++
}
return r.internalRule.GetSplitRuleFromSelection(consideredAttributes, f)
} | [
"func",
"(",
"r",
"*",
"RandomTreeRuleGenerator",
")",
"GenerateSplitRule",
"(",
"f",
"base",
".",
"FixedDataGrid",
")",
"*",
"DecisionTreeRule",
"{",
"var",
"consideredAttributes",
"[",
"]",
"base",
".",
"Attribute",
"\n\n",
"// First step is to generate the random a... | // GenerateSplitRule returns the best attribute out of those randomly chosen
// which maximises Information Gain | [
"GenerateSplitRule",
"returns",
"the",
"best",
"attribute",
"out",
"of",
"those",
"randomly",
"chosen",
"which",
"maximises",
"Information",
"Gain"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/trees/random.go#L17-L47 |
164,794 | sjwhitworth/golearn | trees/random.go | NewRandomTree | func NewRandomTree(attrs int) *RandomTree {
return &RandomTree{
base.BaseClassifier{},
nil,
&RandomTreeRuleGenerator{
attrs,
InformationGainRuleGenerator{},
},
}
} | go | func NewRandomTree(attrs int) *RandomTree {
return &RandomTree{
base.BaseClassifier{},
nil,
&RandomTreeRuleGenerator{
attrs,
InformationGainRuleGenerator{},
},
}
} | [
"func",
"NewRandomTree",
"(",
"attrs",
"int",
")",
"*",
"RandomTree",
"{",
"return",
"&",
"RandomTree",
"{",
"base",
".",
"BaseClassifier",
"{",
"}",
",",
"nil",
",",
"&",
"RandomTreeRuleGenerator",
"{",
"attrs",
",",
"InformationGainRuleGenerator",
"{",
"}",
... | // NewRandomTree returns a new RandomTree which considers attrs randomly
// chosen attributes at each node. | [
"NewRandomTree",
"returns",
"a",
"new",
"RandomTree",
"which",
"considers",
"attrs",
"randomly",
"chosen",
"attributes",
"at",
"each",
"node",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/trees/random.go#L59-L68 |
164,795 | sjwhitworth/golearn | trees/random.go | Fit | func (rt *RandomTree) Fit(from base.FixedDataGrid) error {
rt.Root = InferID3Tree(from, rt.Rule)
return nil
} | go | func (rt *RandomTree) Fit(from base.FixedDataGrid) error {
rt.Root = InferID3Tree(from, rt.Rule)
return nil
} | [
"func",
"(",
"rt",
"*",
"RandomTree",
")",
"Fit",
"(",
"from",
"base",
".",
"FixedDataGrid",
")",
"error",
"{",
"rt",
".",
"Root",
"=",
"InferID3Tree",
"(",
"from",
",",
"rt",
".",
"Rule",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Fit builds a RandomTree suitable for prediction | [
"Fit",
"builds",
"a",
"RandomTree",
"suitable",
"for",
"prediction"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/trees/random.go#L71-L74 |
164,796 | sjwhitworth/golearn | trees/random.go | Predict | func (rt *RandomTree) Predict(from base.FixedDataGrid) (base.FixedDataGrid, error) {
return rt.Root.Predict(from)
} | go | func (rt *RandomTree) Predict(from base.FixedDataGrid) (base.FixedDataGrid, error) {
return rt.Root.Predict(from)
} | [
"func",
"(",
"rt",
"*",
"RandomTree",
")",
"Predict",
"(",
"from",
"base",
".",
"FixedDataGrid",
")",
"(",
"base",
".",
"FixedDataGrid",
",",
"error",
")",
"{",
"return",
"rt",
".",
"Root",
".",
"Predict",
"(",
"from",
")",
"\n",
"}"
] | // Predict returns a set of Instances containing predictions | [
"Predict",
"returns",
"a",
"set",
"of",
"Instances",
"containing",
"predictions"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/trees/random.go#L77-L79 |
164,797 | sjwhitworth/golearn | trees/random.go | Save | func (rt *RandomTree) Save(filePath string) error {
writer, err := base.CreateSerializedClassifierStub(filePath, rt.GetMetadata())
if err != nil {
return err
}
defer func() {
writer.Close()
}()
return rt.SaveWithPrefix(writer, "")
} | go | func (rt *RandomTree) Save(filePath string) error {
writer, err := base.CreateSerializedClassifierStub(filePath, rt.GetMetadata())
if err != nil {
return err
}
defer func() {
writer.Close()
}()
return rt.SaveWithPrefix(writer, "")
} | [
"func",
"(",
"rt",
"*",
"RandomTree",
")",
"Save",
"(",
"filePath",
"string",
")",
"error",
"{",
"writer",
",",
"err",
":=",
"base",
".",
"CreateSerializedClassifierStub",
"(",
"filePath",
",",
"rt",
".",
"GetMetadata",
"(",
")",
")",
"\n",
"if",
"err",
... | // Save outputs this model to a file | [
"Save",
"outputs",
"this",
"model",
"to",
"a",
"file"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/trees/random.go#L93-L102 |
164,798 | sjwhitworth/golearn | trees/random.go | SaveWithPrefix | func (rt *RandomTree) SaveWithPrefix(writer *base.ClassifierSerializer, prefix string) error {
return rt.Root.SaveWithPrefix(writer, prefix)
} | go | func (rt *RandomTree) SaveWithPrefix(writer *base.ClassifierSerializer, prefix string) error {
return rt.Root.SaveWithPrefix(writer, prefix)
} | [
"func",
"(",
"rt",
"*",
"RandomTree",
")",
"SaveWithPrefix",
"(",
"writer",
"*",
"base",
".",
"ClassifierSerializer",
",",
"prefix",
"string",
")",
"error",
"{",
"return",
"rt",
".",
"Root",
".",
"SaveWithPrefix",
"(",
"writer",
",",
"prefix",
")",
"\n",
... | // SaveWithPrefix outputs this model to a file with a prefix. | [
"SaveWithPrefix",
"outputs",
"this",
"model",
"to",
"a",
"file",
"with",
"a",
"prefix",
"."
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/trees/random.go#L105-L107 |
164,799 | sjwhitworth/golearn | trees/random.go | Load | func (rt *RandomTree) Load(filePath string) error {
reader, err := base.ReadSerializedClassifierStub(filePath)
if err != nil {
return err
}
return rt.LoadWithPrefix(reader, "")
} | go | func (rt *RandomTree) Load(filePath string) error {
reader, err := base.ReadSerializedClassifierStub(filePath)
if err != nil {
return err
}
return rt.LoadWithPrefix(reader, "")
} | [
"func",
"(",
"rt",
"*",
"RandomTree",
")",
"Load",
"(",
"filePath",
"string",
")",
"error",
"{",
"reader",
",",
"err",
":=",
"base",
".",
"ReadSerializedClassifierStub",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
... | // Load retrieves this model from a file | [
"Load",
"retrieves",
"this",
"model",
"from",
"a",
"file"
] | 82e59c89f5020c45292c68472908f2150a87422e | https://github.com/sjwhitworth/golearn/blob/82e59c89f5020c45292c68472908f2150a87422e/trees/random.go#L110-L116 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.