text:
package i3layout

import (
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"strings"
	"time"

	"go.i3wm.org/i3"
)

const (
	killWorkspacePrefix = "i3layout-kill-"
)

type Node struct {
	Name    string      `json:"name,omitempty"`
	Type    i3.NodeType `json:"type"`
	Layout  i3.Layout   `json:"layout,omitempty"`
	Percent float64     `json:"percent,omitempty"`
	Marks   []string    `json:"marks,omitempty"`
	Nodes   []*Node     `json:"nodes,omitempty"`
}

type Template Node

func (t *Template) Marshal(w io.Writer) error {
	return json.NewEncoder(w).Encode(t)
}

func (t *Template) Apply(ws *i3.Node, windows Windows) error {
	if t == nil {
		return nil
	}
	// Never apply layouts to i3-internal workspaces, whose names are prefixed
	// with __.
	if strings.HasPrefix(ws.Name, "__") {
		return nil
	}

	tmpLayout, err := ioutil.TempFile("", "i3-layout-*.json")
	tmpLayoutPath := tmpLayout.Name()
	if err != nil {
		return err
	}
	t.Marshal(tmpLayout)
	tmpLayout.Close()
	defer os.Remove(tmpLayoutPath)

	if err := RunI3Cmd(fmt.Sprintf("append_layout %s", tmpLayoutPath)); err != nil {
		return err
	}

	wsSuffix := time.Now().UnixNano()
	killWorkspaceName := fmt.Sprintf("%s-%d", killWorkspacePrefix, wsSuffix)

	var cmds []string
	for _, n := range windows {
		cmds = append(cmds,
			fmt.Sprintf("[con_id=%d] swap container with mark i3layout-%d", n.ID, n.Window),
		)
	}
	cmds = append(cmds, fmt.Sprintf(`rename workspace %s to %s`, ws.Name, killWorkspaceName))
	cmds = append(cmds, fmt.Sprintf(`rename workspace %s to %s`, t.Name, ws.Name))
	if ws.Focused {
		cmds = append(cmds, fmt.Sprintf(`workspace %s`, ws.Name))
	}
	cmds = append(cmds, `[con_mark="^i3layout-"] kill`)

	cmd := strings.Join(cmds, "; ")
	if err := RunI3Cmd(cmd); err != nil {
		return err
	}

	return nil
}


text:
package postgres

import (
	"fmt"

	"github.com/jmoiron/sqlx"
	_ "github.com/lib/pq"
)

func NewStore(dataSourceName string) (*Store, error) {
	db, err := sqlx.Open("postgres", dataSourceName)
	if err != nil {
		return nil, fmt.Errorf("error opening database: %w", err)
	}
	if err := db.Ping(); err != nil {
		return nil, fmt.Errorf("error connecting to database: %w", err)
	}

	return &Store{
		ThreadStore:  &ThreadStore{DB: db},
		PostStore:    &PostStore{DB: db},
		CommentStore: &CommentStore{DB: db},
		UserStore:    &UserStore{DB: db},
	}, nil
}

type Store struct {
	*ThreadStore
	*PostStore
	*CommentStore
	*UserStore
}

license: MIT

repository: mbtamuli/GoLearnGo

license_type: permissive

repo_name: mbtamuli/GoLearnGo

branch_name: refs/heads/main

extension: go


text:
@article{Zhang,
 author = {Zhang, Ruikang and Chouket, Raja and Tebo, Alison G and Plamont, Marie-Aude and Keleman, Zsolt and Gissot, Lionel and Faure, Jean-Denis and Gautier, Arnaud and Croquette, Vincent and Jullien, Ludovic and Le Saux, Thomas},
 journal = {Optica},
 month = {May},
 number = {},
 pages = {},
 title = {Simple imaging protocol for autofluorescence elimination and optical sectioning in fluorescence endomicroscopy},
 volume = {},
 year = {2019}
}

repository: agtebo/academic-kickstart

repo_name: agtebo/academic-kickstart

branch_name: refs/heads/master

extension: bib


text:
@article{foster2006globus,
  title={Globus toolkit version 4: Software for service-oriented systems},
  author={Foster, Ian},
  journal={Journal of computer science and technology},
  volume={21},
  number={4},
  pages={513},
  year={2006},
  publisher={Springer}
}

@book{sotomayor2006globus,
  title={Globus{\textregistered} Toolkit 4: Programming Java Services},
  author={Sotomayor, Borja and Childers, Lisa},
  year={2006},
  publisher={Morgan Kaufmann}
}

@Misc{www-about-globus,
  Title =	 {About the Globus Toolkit},
  HowPublished = {Web Page},
  Note =	 {Accessed: 2017-2-26},
  Key =		 {globus-toolkit-about},
  Owner =	 {S17-ER-1001},
  Url =          {http://toolkit.globus.org/toolkit/about.html}
}

@book{magoules2009introduction,
  title={Introduction to grid computing},
  author={Magoules, Frederic and Pan, Jie and Tan, Kiat-An and Kumar, Abhinit},
  year={2009},
  publisher={CRC Press}
}

@Misc{egee-web,
  Title =	 {EGEE: Enabling Grids for E-Science in Europe},
  HowPublished = {Web Page},
  Note =	 {Accessed: 2017-2-26},
  Owner =	 {S17-ER-1001},
  Url =          {https://eu-egee.org/}
}

@Misc{neesit-web,
  Title =	 {NEESit: Network for Earthquake Engineering Simulation},
  HowPublished = {Web Page},
  Note =	 {Accessed: 2017-2-26},
  Owner =	 {S17-ER-1001},
  Url =          {https://nees.org/}
}

@Misc{teragrid-wiki,
  Title =	 {TeraGrid},
  HowPublished = {Web Page},
  Note =	 {Accessed: 2017-2-26},
  Owner =	 {S17-ER-1001},
  Url =          {https://en.wikipedia.org/wiki/TeraGrid}
}

@book{asadzadeh2005global,
  title={Global grids and software toolkits: A study of four grid middleware technologies},
  author={Asadzadeh, Parvin and Buyya, Rajkumar and Kei, C Ling and Nayar, Deepa and Venugopal, Srikumar},
  year={2005},
  publisher={Wiley Press, New Jersey, USA},
  url={ http://gridbus.csse.unimelb.edu.au/papers/gridmiddlware.doc }
}

@Misc{www-globus-tutorial,
  Title =	 {Globus Toolkit Presentations and Tutorials},
  HowPublished = {Web Page},
  Note =	 {Accessed: 2017-2-26},
  Owner =	 {S17-ER-1001},
  Url =          {http://toolkit.globus.org/toolkit/presentations/}
}

@Misc{www-related-tools,
  Title =	 {Software Tools Related to the Globus Toolkit},
  HowPublished = {Web Page},
  Note =	 {Accessed: 2017-2-26},
  Owner =	 {S17-ER-1001},
  Url =          {http://toolkit.globus.org/toolkit/tools/}
}

@article{schwiegelshohn2010perspectives,
  title={Perspectives on grid computing},
  author={Schwiegelshohn, Uwe and Badia, Rosa M and Bubak, Marian and Danelutto, Marco and Dustdar, Schahram and Gagliardi, Fabrizio and Geiger, Alfred and Hluchy, Ladislav and Kranzlm{\"u}ller, Dieter and Laure, Erwin and others},
  journal={Future Generation Computer Systems},
  volume={26},
  number={8},
  pages={1104--1115},
  year={2010},
  publisher={Elsevier}
}

@Misc{www-uchigago,
  Title =	 {Father of the grid},
  HowPublished = {Web Page},
  Note =	 {Accessed: 2017-2-26},
  Owner =	 {S17-ER-1001},
  Url =          {http://magazine.uchicago.edu/0404/features/index.shtml}
}

@inproceedings{rambadt2002unicore,
  title={UNICORE-Globus Interoperability: Getting the Best of Both Worlds.},
  author={Rambadt, Michael and Wieder, Philipp},
  booktitle={HPDC},
  pages={422},
  year={2002},
  organization={Citeseer}
}

gha_language: TeX


text:
@inproceedings{pannitto2018medea,
  title={MEDEA: Merging Event knowledge and Distributional vEctor Addition},
  author={Pannitto, Ludovica and Lenci, Alessandro},
  booktitle={Fifth Italian Conference on Computational Linguistics (CLiC-it 2018)},
  pages={318--323},
  year={2018},
  organization={Accademia University Press}
}

repository: ellepannitto/my-website

repo_name: ellepannitto/my-website


text:
SECTION = "graphical"
SUMMARY = "Graphviz - Graph Visualization Software"
HOMEPAGE = "http://www.graphviz.org"
LICENSE = "EPL-1.0"
DEPENDS = "cairo pango expat intltool-native gtk-doc gettext-native python"

SRC_URI = " \
    https://ftp.osuosl.org/pub/blfs/conglomeration/graphviz/graphviz-${PV}.tar.gz \
    file://cross_compile.patch \
"

LIC_FILES_CHKSUM = "file://COPYING;md5=9109f5fc16cf963fb3cdd32781b3ce04"
SRC_URI[md5sum] = "5b6a829b2ac94efcd5fa3c223ed6d3ae"
SRC_URI[sha256sum] = "81aa238d9d4a010afa73a9d2a704fc3221c731e1e06577c2ab3496bdef67859e"

PR = "r1"

FILES_${PN}-dev += " \
    /usr/lib/graphviz/*.so \
"

inherit autotools-brokensep pkgconfig

repository: henriknj/meta-labgrid

repo_name: henriknj/meta-labgrid

extension: bb


text:
package main

import (
	"database/sql"
	_ "expvar" // Imported for side-effect of handling /debug/vars.
	"flag"
	"fmt"
	_ "github.com/lib/pq"
	"github.com/rcrowley/go-metrics"
	"github.com/rcrowley/go-tigertonic"
	"log"
	"net/http"
	_ "net/http/pprof" // Imported for side-effect of handling /debug/pprof.
	"net/url"
	"os"
	"os/signal"
	"syscall"
	"time"
)

var db *sql.DB // Global for database connection

var (
	cert   = flag.String("cert", "", "certificate pathname")
	key    = flag.String("key", "", "private key pathname")
	config = flag.String("config", "", "pathname of JSON configuration file")
	listen = flag.String("listen", ":8000", "listen address")

	hMux       tigertonic.HostServeMux
	mux, nsMux *tigertonic.TrieServeMux
)

func init() {
	flag.Usage = func() {
		fmt.Fprintln(os.Stderr, "Usage: example [-cert=<cert>] [-key=<key>] [-config=<config>] [-listen=<listen>]")
		flag.PrintDefaults()
	}
	log.SetFlags(log.Ltime | log.Lmicroseconds | log.Lshortfile)

	// Register endpoints defined in top-level functions below with example
	// uses of Timed go-metrics wrapper.
	mux = tigertonic.NewTrieServeMux()

	mux.Handle(
		"GET",
		"/incidents",
		tigertonic.Timed(tigertonic.Marshaled(getIncidents), "Get-incidents", nil),
	)

	mux.Handle(
		"GET",
		"/incidents/current",
		tigertonic.Timed(tigertonic.Marshaled(getCurrentIncidents), "Get-current-incidents", nil),
	)

	mux.Handle(
		"GET",
		"/incidents/{uuid}",
		tigertonic.Timed(tigertonic.Marshaled(getIncident), "Get-incident-UUID", nil),
	)

	mux.Handle(
		"GET",
		"/incidents/{uuid}/reports",
		tigertonic.Timed(tigertonic.Marshaled(getIncidentReports), "Get-incident-reports", nil),
	)

	// Example use of namespaces.
	nsMux = tigertonic.NewTrieServeMux()
	nsMux.HandleNamespace("", mux)
	nsMux.HandleNamespace("/1.0", mux)
}

func main() {
	flag.Parse()

	// Example use of go-metrics.
	go metrics.Log(
		metrics.DefaultRegistry,
		60e9,
		log.New(os.Stderr, "metrics ", log.Lmicroseconds),
	)

	// Example of parsing a configuration file.
	c := &Config{}
	if err := tigertonic.Configure(*config, c); nil != err {
		log.Fatalln(err)
	}

	// Open up a connection to the DB (well, just get the pool going)
	var err error
	db, err = sql.Open("postgres", os.Getenv("DATABASE_URL"))
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	// Set the allowed CORS origins
	cors := tigertonic.NewCORSBuilder().AddAllowedOrigins("*")

	server := tigertonic.NewServer(
		*listen,

		// Example use of go-metrics to track HTTP status codes.
		tigertonic.CountedByStatus(
			tigertonic.Logged(cors.Build(nsMux), nil),
			"http",
			nil,
		),
	)

	// Example use of server.Close to stop gracefully.
	go func() {
		var err error
		if "" != *cert && "" != *key {
			err = server.ListenAndServeTLS(*cert, *key)
		} else {
			err = server.ListenAndServe()
		}
		if nil != err {
			log.Println(err)
		}
	}()
	ch := make(chan os.Signal)
	signal.Notify(ch, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM)
	log.Println(<-ch)
	server.Close()

}

// GET /incidents
// Returns a GeoJSON FeatureCollection of incidents filtered by specified time range
func getIncidents(u *url.URL, h http.Header, _ interface{}) (int, http.Header, *MinimalIncidentFeatureCollection, error) {

	ts := u.Query().Get("timeStart")
	te := u.Query().Get("timeEnd")

	if ts == "" || te == "" {
		return 0, nil, nil, tigertonic.BadRequest{fmt.Errorf("specify a start and end time")}
	}

	timeFormat := "2006-01-02T15:04:05Z"

	timeStart, err := time.Parse(timeFormat, ts)
	if err != nil {
		return 0, nil, nil, tigertonic.BadRequest{err}
	}

	timeEnd, err := time.Parse(timeFormat, te)
	if err != nil {
		return 0, nil, nil, tigertonic.BadRequest{err}
	}

	ifs, err := minimalIncidentsWithinTimeRange(timeStart, timeEnd)
	if err != nil {
		return 0, nil, nil, tigertonic.InternalServerError{err}
	}

	ifc := minimalIncidentFeatureCollectionForMinimalIncidentFeatures(ifs)

	return http.StatusOK, nil, &ifc, nil
}

// GET /incidents/current
// Returns a GeoJSON FeatureCollection of incidents marked as current
func getCurrentIncidents(u *url.URL, h http.Header, _ interface{}) (int, http.Header, *IncidentFeatureCollection, error) {

	ifs, err := currentIncidentsWithLatestReport()
	if err != nil {
		// Defaulting to 500
		return 0, nil, nil, tigertonic.InternalServerError{err}
	}

	ifc := incidentFeatureCollectionForIncidentFeatures(ifs)

	return http.StatusOK, nil, &ifc, nil
}

// GET /incidents/:uuid
// Returns a GeoJSON FeatureCollection for the given incident UUID.
func getIncident(u *url.URL, h http.Header, _ interface{}) (int, http.Header, *IncidentFeature, error) {

	uuid := u.Query().Get("uuid")
	if uuid == "" {
		return 0, nil, nil, tigertonic.BadRequest{fmt.Errorf("supply an incident UUID")}
	}

	fea, err := incidentFeatureForUUID(uuid)
	if err != nil {
		// Defaulting to 500
		// TODO handle 404
		return 0, nil, nil, tigertonic.InternalServerError{err}
	}

	return http.StatusOK, nil, &fea, nil
}

// GET /incidents/:uuid/reports
// Returns a GeoJSON FeatureCollection of incidents marked as current
func getIncidentReports(u *url.URL, h http.Header, _ interface{}) (int, http.Header, *ReportFeatureCollection, error) {

	rfs, err := reportsForIncident(u.Query().Get("uuid"))
	if err != nil {
		// Defaulting to 500
		// TODO handle 404
		return 0, nil, nil, tigertonic.InternalServerError{err}
	}

	rfc := reportFeatureCollectionForReportFeatures(rfs)

	return http.StatusOK, nil, &rfc, nil
}

repository: DylanFM/bushfires

repo_name: DylanFM/bushfires

gha_language: API Blueprint


text:
package comment_test

import (
	"testing"
	"time"

	"golang.org/x/net/context"

	"github.com/almighty/almighty-core/comment"
	"github.com/almighty/almighty-core/gormsupport"
	"github.com/almighty/almighty-core/gormsupport/cleaner"
	"github.com/almighty/almighty-core/rendering"
	"github.com/almighty/almighty-core/resource"
	uuid "github.com/satori/go.uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/stretchr/testify/suite"
)

type TestCommentRepository struct {
	gormsupport.DBTestSuite

	clean func()
}

func TestRunCommentRepository(t *testing.T) {
	resource.Require(t, resource.Database)
	suite.Run(t, &TestCommentRepository{DBTestSuite: gormsupport.NewDBTestSuite("../config.yaml")})
}

func (test *TestCommentRepository) SetupTest() {
	test.clean = cleaner.DeleteCreatedEntities(test.DB)
}

func (test *TestCommentRepository) TearDownTest() {
	test.clean()
}

func newComment(parentID, body, markup string) *comment.Comment {
	return &comment.Comment{
		ParentID:  parentID,
		Body:      body,
		Markup:    markup,
		CreatedBy: uuid.NewV4(),
	}
}

func (test *TestCommentRepository) createComment(c *comment.Comment) {
	repo := comment.NewCommentRepository(test.DB)
	err := repo.Create(context.Background(), c)
	require.Nil(test.T(), err)
}

func (test *TestCommentRepository) createComments(comments []*comment.Comment) {
	repo := comment.NewCommentRepository(test.DB)
	for _, comment := range comments {
		err := repo.Create(context.Background(), comment)
		require.Nil(test.T(), err)
	}
}

func (test *TestCommentRepository) TestCreateCommentWithMarkup() {
	// given
	repo := comment.NewCommentRepository(test.DB)
	comment := newComment("A", "Test A", rendering.SystemMarkupMarkdown)
	// when
	repo.Create(context.Background(), comment)
	// then
	assert.NotNil(test.T(), comment.ID, "Comment was not created, ID nil")
	require.NotNil(test.T(), comment.CreatedAt, "Comment was not created?")
	assert.False(test.T(), comment.CreatedAt.After(time.Now()), "Comment was not created, CreatedAt after Now()?")
}

func (test *TestCommentRepository) TestCreateCommentWithoutMarkup() {
	// given
	repo := comment.NewCommentRepository(test.DB)
	comment := newComment("A", "Test A", "")
	// when
	repo.Create(context.Background(), comment)
	// then
	assert.NotNil(test.T(), comment.ID, "Comment was not created, ID nil")
	require.NotNil(test.T(), comment.CreatedAt, "Comment was not created?")
	assert.False(test.T(), comment.CreatedAt.After(time.Now()), "CreatedAt after Now()?")
	assert.Equal(test.T(), rendering.SystemMarkupDefault, comment.Markup)
}

func (test *TestCommentRepository) TestSaveCommentWithMarkup() {
	// given
	repo := comment.NewCommentRepository(test.DB)
	comment := newComment("A", "Test A", rendering.SystemMarkupPlainText)
	test.createComment(comment)
	assert.NotNil(test.T(), comment.ID, "Comment was not created, ID nil")
	// when
	comment.Body = "Test AB"
	comment.Markup = rendering.SystemMarkupMarkdown
	repo.Save(context.Background(), comment)
	offset := 0
	limit := 1
	comments, _, err := repo.List(context.Background(), comment.ParentID, &offset, &limit)
	// then
	require.Nil(test.T(), err)
	require.Equal(test.T(), 1, len(comments), "List returned more then expected based on parentID")
	assert.Equal(test.T(), "Test AB", comments[0].Body)
	assert.Equal(test.T(), rendering.SystemMarkupMarkdown, comments[0].Markup)
}

func (test *TestCommentRepository) TestSaveCommentWithoutMarkup() {
	// given
	repo := comment.NewCommentRepository(test.DB)
	comment := newComment("A", "Test A", rendering.SystemMarkupMarkdown)
	test.createComment(comment)
	assert.NotNil(test.T(), comment.ID, "Comment was not created, ID nil")
	// when
	comment.Body = "Test AB"
	comment.Markup = ""
	repo.Save(context.Background(), comment)
	offset := 0
	limit := 1
	comments, _, err := repo.List(context.Background(), comment.ParentID, &offset, &limit)
	// then
	require.Nil(test.T(), err)
	require.Equal(test.T(), 1, len(comments), "List returned more then expected based on parentID")
	assert.Equal(test.T(), "Test AB", comments[0].Body)
	assert.Equal(test.T(), rendering.SystemMarkupPlainText, comments[0].Markup)
}

func (test *TestCommentRepository) TestDeleteComment() {
	t := test.T()
	resource.Require(t, resource.Database)

	defer cleaner.DeleteCreatedEntities(test.DB)()

	repo := comment.NewCommentRepository(test.DB)

	parentID := "AA"
	c := &comment.Comment{
		ParentID:  parentID,
		Body:      "Test AA",
		CreatedBy: uuid.NewV4(),
		ID:        uuid.NewV4(),
	}

	repo.Create(context.Background(), c)
	if c.ID == uuid.Nil {
		t.Errorf("Comment was not created, ID nil")
	}

	c.Body = "Test AB"
	err := repo.Delete(context.Background(), c.ID)

	if err != nil {
		t.Error("Failed to Delete", err.Error())
	}

}

func (test *TestCommentRepository) TestCountComments() {
	// given
	repo := comment.NewCommentRepository(test.DB)
	parentID := "A"
	comment1 := newComment("A", "Test A", rendering.SystemMarkupMarkdown)
	comment2 := newComment("B", "Test B", rendering.SystemMarkupMarkdown)
	comments := []*comment.Comment{comment1, comment2}
	test.createComments(comments)
	// when
	count, err := repo.Count(context.Background(), parentID)
	// then
	require.Nil(test.T(), err)
	assert.Equal(test.T(), 1, count)
}

func (test *TestCommentRepository) TestListComments() {
	// given
	repo := comment.NewCommentRepository(test.DB)
	comment1 := newComment("A", "Test A", rendering.SystemMarkupMarkdown)
	comment2 := newComment("B", "Test B", rendering.SystemMarkupMarkdown)
	comments := []*comment.Comment{comment1, comment2}
	test.createComments(comments)
	// when
	offset := 0
	limit := 1
	comments, _, err := repo.List(context.Background(), comment1.ParentID, &offset, &limit)
	// then
	require.Nil(test.T(), err)
	require.Equal(test.T(), 1, len(comments))
	assert.Equal(test.T(), comment1.Body, comments[0].Body)
}

func (test *TestCommentRepository) TestListCommentsWrongOffset() {
	// given
	repo := comment.NewCommentRepository(test.DB)
	comment1 := newComment("A", "Test A", rendering.SystemMarkupMarkdown)
	comment2 := newComment("B", "Test B", rendering.SystemMarkupMarkdown)
	comments := []*comment.Comment{comment1, comment2}
	test.createComments(comments)
	// when
	offset := -1
	limit := 1
	_, _, err := repo.List(context.Background(), comment1.ParentID, &offset, &limit)
	// then
	assert.NotNil(test.T(), err)
}

func (test *TestCommentRepository) TestListCommentsWrongLimit() {
	// given
	repo := comment.NewCommentRepository(test.DB)
	comment1 := newComment("A", "Test A", rendering.SystemMarkupMarkdown)
	comment2 := newComment("B", "Test B", rendering.SystemMarkupMarkdown)
	comments := []*comment.Comment{comment1, comment2}
	test.createComments(comments)
	// when
	offset := 0
	limit := -1
	_, _, err := repo.List(context.Background(), comment1.ParentID, &offset, &limit)
	// then
	assert.NotNil(test.T(), err)
}

func (test *TestCommentRepository) TestLoadComment() {
	// given
	repo := comment.NewCommentRepository(test.DB)
	comment := newComment("A", "Test A", rendering.SystemMarkupMarkdown)
	test.createComment(comment)
	// when
	loadedComment, err := repo.Load(context.Background(), comment.ID)
	require.Nil(test.T(), err)
	assert.Equal(test.T(), comment.ID, loadedComment.ID)
	assert.Equal(test.T(), comment.Body, loadedComment.Body)
}

repository: kbsingh/almighty-core

repo_name: kbsingh/almighty-core

gha_language: Go


text:
@book{ShSh14,
    place={Cambridge},
    title={Understanding Machine Learning: From Theory to Algorithms},
    DOI={10.1017/CBO9781107298019},
    publisher={Cambridge University Press},
    author={Shalev-Shwartz, Shai and Ben-David, Shai},
    year={2014}
}
@book{Ag16,
    author = "Aggarwal, Charu C.",
    year = "2016",
    title = "Recommender Systems - The Textbook",
    isbn = "978-3-319-29659-3",
    publisher = "Springer"
}
@ARTICLE{KoBeVo09,
    author={Y. {Koren} and R. {Bell} and C. {Volinsky}},
    journal={Computer},
    title={Matrix Factorization Techniques for Recommender Systems},
    year={2009},
    volume={42},
    number={8},
    pages={30-37},
    keywords={information filtering;matrix decomposition;retail data processing;matrix factorization technique;recommender system;Netflix Prize competition;product recommendation system;nearest neighbor technique;Recommender systems;Motion pictures;Filtering;Collaboration;Sea measurements;Predictive models;Genomics;Bioinformatics;Nearest neighbor searches;Computational intelligence;Netflix Prize;Matrix factorization},
    doi={10.1109/MC.2009.263},
    ISSN={0018-9162},
    month={Aug},
}

@Booklet{Gi19,
	AUTHOR = {Giesen, Joachim},
	TITLE = {Statistical Learning Theory},
	TYPE = {Lecture script},
	INSTITUTION = {Friedrich-Schiller-Universität Jena},
	YEAR = {2019}
}

@Book{NoWr06,
	Title                    = {Numerical Optimization},
	Author                   = {Jorge Nocedal and Stephen J. Wright},
	Publisher                = {Springer},
	Year                     = {2006},
	Address                  = {New York, NY, USA},
	Edition                  = {second}
}

repository: MarkusFischer/sll-recommender

repo_name: MarkusFischer/sll-recommender


text:
SUMMARY = "uchardet is an encoding detector library"
LICENSE = "MPLv1.1"
LIC_FILES_CHKSUM = "file://COPYING;md5=6ecda54f6f525388d71d6b3cd92f7474"

inherit cmake

SRC_URI = "https://www.freedesktop.org/software/uchardet/releases/uchardet-0.0.7.tar.xz"
SRC_URI[md5sum] = "623406dac5c5ad89e40eedd7f279efae"
SRC_URI[sha256sum] = "3fc79408ae1d84b406922fa9319ce005631c95ca0f34b205fad867e8b30e45b1"

repository: ni/meta-openembedded

repo_name: ni/meta-openembedded

branch_name: refs/heads/nilrt/master/hardknott

gha_license_id: MIT

gha_language: BitBake


text:
@article{Frit2,
  author = {Fritz, U. and Corti, C. and P\"{a}ckert, M.},
  doi = {10.1007/s13127-011-0069-8},
  journal = {Actes du $4^{\textrm{ème}}$ Congrès Français d'Acoustique},
  pages = {71-80},
  timestamp = {2015-02-24 12:14:36 +0100},
  title = {Test of markupconversion: Italics, bold, superscript, subscript, and small caps: Mitochondrial DNA$_{\textrm{2}}$ sequences suggest unexpected phylogenetic position of Corso-Sardinian grass snakes (\textit{Natrix cetti}) and \textbf{do not} support their \textsc{species status}, with notes on phylogeography and subspecies delineation of grass snakes.},
  volume = {12},
  year = {2012}
}

@article{AdcroftETAL:1997,
      author	= "Adcroft, Alistair  and  Chris Hill
    		   and  John Marshall",
      year		= "1997",
      title		= "Representation of Topography by Shaved Cells in a
    		   Height Coordinate Ocean Model",
      journal	= "Monthly Weather Review",
      volume	= "125",
      pages		= "2293-2315"}

repository: FlamingTempura/bibtex-tidy

repo_name: FlamingTempura/bibtex-tidy


text:
# Copyright (c) 2012-2013 LG Electronics, Inc.

SUMMARY = "Loadable frameworks for sync services"
SECTION = "webos/frameworks"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Apache-2.0;md5=89aea4e17d99a7cacdbeed46a0096b10"

PV = "1.1-3+git${SRCPV}"
SRCREV = "1e158faa0b17cffc45888d1b3b1b6ac54c57dd89"

inherit webos_ports_ose_repo
inherit webos_filesystem_paths
inherit allarch

SRC_URI = "${WEBOS_PORTS_GIT_REPO_COMPLETE}"
S = "${WORKDIR}/git"

do_install() {
    install -d ${D}${webos_frameworksdir}

    for FRAMEWORK in `ls -d1 ${S}/mojoservice*` ; do
        FRAMEWORK_DIR=`basename $FRAMEWORK`
        install -d ${D}${webos_frameworksdir}/$FRAMEWORK_DIR/version/1.0/
        cp -vrf $FRAMEWORK/* ${D}${webos_frameworksdir}/$FRAMEWORK_DIR/version/1.0/
        # remove test and jasminetest dirs
        rm -vrf ${D}${webos_frameworksdir}/$FRAMEWORK_DIR/version/1.0/*test
    done
}

FILES:${PN} += "${webos_frameworksdir}"

repository: webOS-ports/meta-webos-ports

repo_name: webOS-ports/meta-webos-ports

branch_name: refs/heads/kirkstone


text:
@article{SURVEY_PROCESS_MINING_DRIFT:2021,
  year = {2021},
  publisher = {ACM},
  author = {Denise Maria Vecino Sato and Sheila Cristiana de Freitas and Jean Paul Barddal and Edson Emilio Scalabrin},
  title = {A Survey on Concept Drift in Process Mining},
  journal = {ACM Computing Surveys},
  abstract={Concept drift in process mining (PM) is a challenge as classical
  methods assume processes are in a steady-state, i.e., events share the same
  process version. We conducted a systematic literature review on the
  intersection of these areas, and thus, we review concept drift in process
  mining and bring forward a taxonomy of existing techniques for drift
  detection and online process mining for evolving environments. Existing works
  depict that (i) PM still primarily focuses on offline analysis, and (ii) the
  assessment of concept drift techniques in processes is cumbersome due to the
  lack of common evaluation protocol, datasets, and metrics.}
}

@inproceedings{LUCCA1_IJCNN:2021,
  author    = {Lucca Portes Cavalheiro and Jean Paul Barddal and Alceu de Souza Britto Jr. and Laurent Heutte},
  title     = {Dynamically Selected Ensemble for Data Stream Classification},
  booktitle = {International Joint Conference on Neural Networks (IJCNN)},
  year      = {2021},
  abstract  = {Mining data streams is a hot topic in the machine learning (ML) community.
  In addition to learning and updating accurate models over time, these techniques must
  respect constraints that are not necessarily as strong in batch mode, such as time processing
  and memory consumption efficiency. A successful family of techniques in batch ML is dynamic
  classifier selection (DCS). However, these are roughly overlooked in data stream mining.
  In this paper, we propose a novel dynamic classifier selection framework for data streams
  called Double Dynamic Classifier Selection (DDCS). We compare DDCS against state-of-art methods
  for mining data streams in both synthetic and real-world datasets. Results depict that DDCS not
  only outperforms the state-of-art ensemble methods for data stream classification in terms of
  accuracy but is also significantly more efficient in terms of processing time and memory consumption.}
}

@inproceedings{LUCCA2_IJCNN:2021,
  author    = {Lucca Portes Cavalheiro and Marco Antonio Alves Zanata and Jean Paul Barddal},
  title     = {Towards the Overcome of Performance Pitfalls in Data Stream Mining Tools},
  booktitle = {International Joint Conference on Neural Networks (IJCNN)},
  year      = {2021},
  abstract  = {Data stream mining is an essential task in today's scientific community.
  It allows machine learning models to be updated over time as new data becomes available.
  Three pillars should be accounted for when selecting an appropriate algorithm for data stream mining: accuracy, processing time, and memory consumption.
  To develop and assess machine learning models in streaming scenarios, different tools have been developed, where the Massive Online Analysis, written in Java, and scikit-multiflow, written in Python, are in the spotlight.
  Despite the ease of use of both tools, neither are focused on performance, which puts in jeopardy the usage of the computational resources.
  In this paper, we show that with the right tools, Python libraries reach performance comparable to C/C++.
  More specifically, we show how optimized implementations in scikit-multiflow using low-level languages, i.e., C++, C++ with Intel Intrinsics, and Rust; with bindings to Python vastly overcome existing tools in computational resources usage while keeping predictive performance intact.}
}

@inproceedings{DENISE:2021,
  author    = {Denise Maria Vecino Sato and Jean Paul Barddal and Edson Emilio Scalabrin},
  title     = {Interactive Process Drift Detection Framework},
  booktitle = {International Conference on Artificial Intelligence and Soft Computing (ICAISC)},
  year      = {2021},
  abstract  = {This paper presents a novel tool for detecting drifts in process models.
  The tool targets the challenge of defining the better parameter configuration for detecting
  drifts by providing an interactive user interface. Using this interface, the user can quickly
  change the parameters and verify how the process evolved. The process evolution is presented
  in a timeline of process models, simulating a ``replay'' of models over time. One instantiation
  of the framework was implemented using a fixed-size sliding window, discovering process maps
  using directly-follows graphs (DFGs), and calculating nodes and edges similarities. This instantiation
  was evaluated using a benchmarking dataset of simple and complex drift patterns. The tool correctly
  detected 17 from the 18 change patterns, thus confirming its potential when an adequate window size
  is set. The user interface shows that replaying the process models provides a visual understanding of
  the changing process. The concept drift is explained by the similarity metrics' differences, thus
  allowing drift localization. }
}

@article{ESWA_SUPERMARKET:2021,
  year = {2021},
  publisher = {Elsevier},
  author = {Ant\^{o}nio David Viniski and Jean Paul Barddal and Alceu de Souza Britto Jr. and Fabricio Enembreck and Humberto Vinicius Aparecido de Campos},
  title = {A case study of batch and incremental recommender systems in supermarket data under concept drifts and cold start},
  journal = {Expert Systems with Applications},
  abstract={Recommender systems uncover relationships between users and items, thus allowing personalized recommendations.
            Nonetheless, users' preferences may change over time, the so-called concept drifts; or new users and items may appear,
            making the recommender system unable to accurately map the relationship between users and items due to the cold start problem.
            Consequently, concept drift and cold start are challenges that downgrade the recommender system’s predictive performance.
            This paper assesses existing approaches for collaborative-filtering recommender systems over a real supermarket dataset that
            exhibits both of the issues mentioned above.
            For this purpose, our comparative analysis encompasses batch and streaming learning approaches.
            As a result, we can observe that streaming-based models achieve better recommendation rates since these are tailored to fit the concept drift.
            More specifically, the predictive performance of streaming-based recommendations increases by up to 21% over those provided by batch methods.
            The supermarket dataset used in experimentation is also made publicly available for future studies and recommender systems comparisons.}
}

@inproceedings{BARDDAL_PAKDD:2021,
  author    = {Antônio David Viniski and Jean Paul Barddal and Alceu de Souza Britto Jr.},
  title     = {UKIRF: An Item Rejection Framework for Improving Negative Items Sampling in One-Class Collaborative Filtering},
  booktitle = {Pacific-Asia Conference on Knowledge Discovery and Data Mining (PAKDD)},
  year      = {2021},
  abstract  = {Collaborative Filtering (CF) is one of the most successful techniques in recommender systems.
               Most CF scenarios depict positive-only implicit feedback, which means that negative feedback is unavailable.
               Therefore, One-Class Collaborative Filtering (OCCF) techniques have been tailored to tackling these scenarios.
               Nonetheless, several OCCF models still require negative observations during training, and thus, a popular approach
               is to consider randomly selected unknown relationships as negative.
               In this work, we bring forward a novel approach for selecting negative items called Unknown Item Rejection Framework (UKIRF).
               More specifically, we instantiate UKIRF using similarity approaches, i.e., TF-IDF and Cosine, to reject items that are similar
               to those a user interacted with. We apply UKIRF to different OCCF models in different datasets and show that it improves the
               recall rates up to 24% when compared to random sampling. }
}

@inproceedings{BARDDAL_ICPR:2021,
  author    = {Marcos Monteiro and Alceu de Souza Britto Jr and Jean Paul Barddal and Luiz Soares Oliveira and Robert Sabourin},
  title     = {Classifier Pool Generation based on a Two-level Diversity Approach},
  booktitle = {International Conference on Pattern Recognition (ICPR)},
  year      = {2021},
  abstract  = {This paper describes a classifier pool generation method
  guided by the diversity estimated on the data complexity and classifier
  decisions. First, the behavior of complexity measures is assessed by
  considering several subsamples of the dataset. The complexity measures
  with high variability across the subsamples are selected for posterior
  pool adaptation, where an evolutionary algorithm optimizes diversity in
  both complexity and decision spaces. A robust experimental protocol with
  28 datasets and 20 replications is used to evaluate the proposed method.
  Results show significant accuracy improvements in 69.4\% of the experiments
  when Dynamic Classifier Selection and Dynamic Ensemble Selection methods
  are applied.  }
}

@inproceedings{BARDDAL_SMC1_2020,
  author    = {Jean Paul Barddal, Fabricio Enembreck, Lucas Loezer, and Riccardo Lanzuolo},
  title     = {Combining Slow and Fast Learning for Improved Credit Scoring  },
  booktitle = {IEEE International Conference on Systems, Man, and Cybernetics (IEEE SMC)},
  year      = {2020},
  abstract  = {The financial credibility of a person is a relevant factor
to determine whether a loan should be approved or not, and
it is quantified by a credit score, which is computed using
past performance on debt obligations, profiling, and other
data available.
Credit scoring becomes even a hotter topic in emerging
countries, as interest rates and customer behavior swiftly
vary, given the economic (in)stability of the country and
as fintechs are chasing robust solutions for improved
credit scoring solutions.
Batch machine learning is often deployed for credit
scoring, yet, they are tailored for static scenarios, i.e.,
they are not prepared to swiftly detect and adapt to
changes in customer behavior, thus leading to slow recovery
in such scenarios.
In this paper, we bring forward an analysis on how batch
machine learning can be combined with data stream mining
techniques, thus leading to better recognition rates in
credit scoring scenarios.
We analyze three different real-world datasets from
Brazilian financial institutions, whilst keeping their
secrecy preserved, and show how batch and stream learning
can be combined towards improved credit scoring systems, as
well as highlighting relevant gaps that still require
attention.  }
}

@inproceedings{BARDDAL_SMC2_2020,
  author    = {Paulo Ricardo Lisboa de Almeida, Luiz Oliveira, Alceu Souza Britto Jr, and Jean Paul Barddal},
  title     = {Naïve Approaches to Deal with Concept Drifts },
  booktitle = {IEEE International Conference on Systems, Man, and Cybernetics (IEEE SMC)},
  year      = {2020},
  abstract  = {A common problem in machine learning is to find
representative real-world problems to put the methods to
test. When developing approaches to deal with concept
drifts, some datasets such as the Forest Covertype and
Nebraska Weather are a common choice for testing. We argue
that some well-known real-world concept drift datasets
present a high serial dependence in the target class and
may have only minor changes. With this in mind, we propose
the use of naïve methods that should be used for
comparison with methods that deal with concept drifts. The
experimental results using six real-world well-known
concept drift datasets show that the naïve
approaches can be better than some methods to deal with
possible concept drifts in datasets such as the Forest
Covertype, Electricity, and Nebraska Weather. These results
suggest that some widely used datasets may be trivial from
the concept drift standpoint, and thus, should be avoided
or at least the results should be compared with the
proposed naïve methods.}
}

@inproceedings{BARDDAL_SMC3_2020,
  author    = {Marcos Alberto Mochinski, Jean Paul Barddal, and Fabricio Enembreck},
  title     = {Improving Multiple Time Series Forecasting with Data Stream Mining Algorithms  },
  booktitle = {IEEE International Conference on Systems, Man, and Cybernetics (IEEE SMC)},
  year      = {2020},
  abstract  = {This paper proposes a hybrid ensemble learning approach
that combines statistical and data stream mining algorithms
to obtain better forecasting performance in multiple time
series prediction problems. Although some multiple time
series algorithms perform surprisingly well in a variety of
domains, it is well-known that no one is dominant for every
existent domain. Therefore, we developed a meta-technique
based on data stream mining and static ensemble selection
strategy and evaluated its forecasting goodness-of-fit in
time series datasets from M3 and M4 competitions. After
training different regression models, we show how the
combination of auto.arima and AdaGrad lead to improved
forecasting rates, thus surpassing the results of
state-of-art algorithms.}
}

@inproceedings{BARDDAL_SMC4_2020,
  author    = {Eduardo Ferreira José, Fabricio Enembreck, and Jean Paul Barddal},
  title     = {{ADADRIFT}: An Adaptive Learning Technique for Long-History Stream-Based Recommender Systems  },
  booktitle = {IEEE International Conference on Systems, Man, and Cybernetics (IEEE SMC)},
  year      = {2020},
  abstract  = {Adaptive recommender systems are increasingly showing their
importance as profiling is a dynamic problem. Their goal is
to update recommendation models as new interactions take
place, thus swiftly adapting to drifts in the user’s
behavior and desires, and item’s audience. However,
existing recommendation algorithms usually do not perform
well during drifts, as they take long to adapt to changes,
or these updates are suboptimal since they account for all
profiles’ preferences equally, which is often untrue as
each individual and its changes are unique. In this paper,
we propose the ADADRIFT algorithm to deal with user and
item-based drifts in adaptive recommender systems using
personalized learning rates based on profile statistics.
The experiments using stream-based recommender systems
(ISGD and BRISMF) across four different datasets show that
ADADRIFT surpasses ADADELTA with significant improvements
in recommendation rates. The best results appear when the
data streams have a long history of the users’ or items’
interactions and drifts become noticeable. The
experimentation in this work highlight the importance of
handling drifts in recommender systems. }
}

@article{BARDDAL_LESSONS_LEARNED:2020,
title = "Lessons learned from data stream classification applied to credit scoring",
journal = "Expert Systems with Applications",
pages = "113899",
year = "2020",
issn = "0957-4174",
doi = "https://doi.org/10.1016/j.eswa.2020.113899",
url = "http://www.sciencedirect.com/science/article/pii/S0957417420306928",
author = "Jean Paul Barddal and Lucas Loezer and Fabrício Enembreck and Riccardo Lanzuolo",
keywords = "Credit scoring, Machine learning datasets, Data stream classification",
abstract = "The financial credibility of a person is a factor used to determine whether a loan should be approved or not, and this is quantified by a ‘credit score,’ which is calculated using a variety of factors, including past performance on debt obligations, profiling, amongst others. Machine learning has been widely applied to automate the development of effective credit scoring models over the years. Yet, studies show that the development of robust credit scoring models may take longer than a year, and thus, if the behavior of customers changes over time, the model will be outdated even before its deployment. In this paper, we made 3 anonymized real-world credit scoring datasets available alongside the results obtained. In each of these datasets, we verify whether the credit scoring task should be thought as an ephemeral scenario since many of the variables may drift over time, and thus, data stream mining techniques should be used since they were tailored for incremental learning and to detect and adapt to changes in the data distribution. Therefore, we compare both traditional batch machine learning algorithms with data stream algorithms in different validation schemes using both Kolmogorov–Smirnov and Population Stability Index metrics. Furthermore, we also provide insights on the importance of features according to their Information Value, Mean Decrease Impurity, and Mean Positional Gain metrics, such that the last depicts changes in the importance of features over time. For 2 of the 3 tested datasets, the results obtained by data stream learners are comparable to predictive models currently in use, thus showing the efficiency of data stream classification for the credit scoring task."
}

@article{Barddal_Enembreck:2020,
  year = {2020},
  publisher = {Springer},
  author = {Jean Paul Barddal and Fabricio Enembreck},
  title = {Regularized and incremental decision trees for data streams},
  journal = {Annals of Telecommunications},
  abstract={Decision trees are a widely used family of methods for learning predictive models from both batch and streaming data. Despite depicting positive results in a multitude of applications, incremental decision trees continuously grow in terms of nodes as new data becomes available, i.e., they eventually split on all features available, and also multiple times using the same feature; thus leading to unnecessary complexity and overfitting. With this behavior, incremental trees lose the ability to generalize well, be human-understandable and computationally efficient. To tackle these issues, we proposed in a previous study a regularization scheme for Hoeffding decision trees that: (i) uses a penalty factor to control the gain obtained by creating a new split node using a feature that has not been used thus far; and (ii) uses information from previous splits in the current branch to determine whether the gain observed indeed justifies a new split. In this paper, we extend this analysis and apply the proposed regularization scheme to other types of incremental decision trees and report the results in both synthetic and real-world scenarios. The main interest is to verify whether and how the proposed regularization scheme affects the different types of incremental trees. Results show that in addition to the original Hoeffding Tree, the Adaptive Random Forest also benefits from regularization, yet, McDiarmid Trees and Extremely Fast Decision trees observe declines in accuracy.}
}

@inproceedings{Hochuli2020,
  author    = {Andr\'{e} Gustavo Hochuli and Alceu de Souza Britto Jr. and Jean Paul Barddal and Luiz Eduardo Soares Oliveira and Robert Sabourin},
  title     = {An End-to-End Approach for Recognition of Modern and Historical Handwritten Numeral Strings},
  booktitle = {Proceedings of the 2020 International Joint Conference on Neural Networks (IJCNN)
               Glasgow, Scotland},
  year      = {2020},
  abstract = {An end-to-end solution for handwritten numeral string recognition is proposed, in which the numeral string is considered as composed of objects automatically detected and recognized by a YoLo-based model. The main contribution of this paper is to avoid heuristic-based methods for string preprocessing and segmentation, the need for task-oriented classifiers, and also the use of specific constraints related to the string length. A robust experimental protocol based on several numeral string datasets, including one composed of historical documents, has shown that the proposed method is a feasible end-to-end solution for numeral string recognition. Besides, it reduces the complexity of the string recognition task considerably since it drops out classical steps, in special preprocessing, segmentation, and a set of classifiers devoted to strings with a specific length.}
}

@inproceedings{Loezer2020,
  author    = {Lucas Loezer and Fabricio Enembreck and Jean Paul Barddal and Alceu de Souza Britto Jr.},
  title     = {Cost-sensitive learning for imbalanced data streams},
  booktitle = {Proceedings of the 34rd Annual {ACM} Symposium on Applied Computing,
               {SAC} 2020, Brno, Czech Republic, March 30 - April 3, 2020},
  year      = {2020},
  abstract = {The data imbalance problem hampers the classification task. In streaming environments, this becomes even more cumbersome as the proportion of classes can vary over time. Approaches based on misclassification costs can be used to mitigate this problem. In this paper, we present the Cost-sensitive Adaptive Random Forest (CSARF) and compare it to the Adaptive Random Forest (ARF) and ARF with Resampling (ARF$_{RE}$) in six real-world and six synthetic data sets with different class ratios. The empirical study analyzes two misclassification costs strategies of the CSARF and shows that the CSARF obtained statistically superior w.r.t. the average recall and average F1 when compared to ARF.}
}

@article{Obladen2019,
  url = {http://buscalegis.ufsc.br/revistas/index.php/observatoriodoegov/article/view/314},
  year = {2020},
  month = jan,
  volume = {1},
  number = {18},
  pages = {107--126},
  author = {Cinthia Obladen de Almendra Freitas and Jean Paul Barddal},
  title = {AN\'{A}LISE PREDITIVA E DECIS\~{O}ES JUDICIAIS: controvérsia ou realidade?},
  journal = {Revista Democracia Digital e Governo Eletrônico},
  abstract={In this paper, we provide an overview of how Data Analytics, Big Data, and Machine Learning may assist the judicial system by providing insightful information to citizens, police, lawyers, and judges, in a fast and accurate way. We conduct a bidirectional analysis between Law and Predictive Analytics applying the deductive method and bibliographic technique. We report concerns that Law should have with the application of computational techniques in different scenarios, mainly in the judicial system. Finally, we bring forward controversies between these areas, such as the new companies that target the use of personal and sensitive data in Law applications, and how these are potentially hurting fundamental rights and leading to biases in critical systems, wuch as predictive systems for crime recidivism.}
}

@article{Gomes2019,
  doi = {10.1145/3373464.3373470},
  url = {https://doi.org/10.1145/3373464.3373470},
  year = {2019},
  month = nov,
  publisher = {Association for Computing Machinery ({ACM})},
  volume = {21},
  number = {2},
  pages = {6--22},
  author = {Heitor Murilo Gomes and Jesse Read and Albert Bifet and Jean Paul Barddal and Jo{\~{a}}o Gama},
  title = {Machine learning for streaming data},
  journal = {{ACM} {SIGKDD} Explorations Newsletter},
  abstract={Incremental learning, online learning, and data stream learning are terms commonly associated with learning algorithms that update their models given a continuous influx of data without performing multiple passes over data. Several works have been devoted to this area, either directly or indirectly as characteristics of big data processing, i.e., Velocity and Volume. Given the current industry needs, there are many challenges to be addressed before existing methods can be efficiently applied to real-world problems. In this work, we focus on elucidating the connections among the current state-of-the-art on related fields; and clarifying open challenges in both academia and industry. We treat with special care topics that were not thoroughly investigated in past position and survey papers. This work aims to evoke discussion and elucidate the current research opportunities, highlighting the relationship of different subareas and suggesting courses of action when possible.}
}

@article{JOURNAL_FRANKIE,
 author = {Yuan, Lanqin and Pfahringer, Bernhard and Barddal, Jean Paul},
 title = {Addressing Feature Drift in Data Streams Using Iterative Subset Selection},
 journal = {SIGAPP Appl. Comput. Rev.},
 issue_date = {March 2019},
 volume = {19},
 number = {1},
 month = apr,
 year = {2019},
 issn = {1559-6915},
 pages = {20--33},
 numpages = {14},
 url = {http://doi.acm.org/10.1145/3325061.3325063},
 doi = {10.1145/3325061.3325063},
 acmid = {3325063},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {backward feature elimination, concept drift, data stream mining, embedded feature selection, feature selection, iterative subset selection},
 abstract = {Data streams are prone to various forms of concept drift over time including, for instance, changes to the relevance of features. This specific kind of drift is known as feature drift and requires techniques tailored not only to determine which features are the most important but also to take advantage of them. Feature selection has been studied and shown to improve classifier performance in standard batch data mining, yet it is mostly unexplored in data stream mining. This paper presents a novel method of feature subset selection specialized for dealing with the occurrence of feature drifts called Iterative Subset Selection (ISS), which splits the feature selection process into two stages by first ranking the features using some scoring function, and then iteratively selecting feature subsets using this ranking. This work further extends upon our prior work by exploring feeding information from the subset selection stage back into the ranking process. Applying our method to the Naïve Bayes and k-Nearest Neighbour classifier, we obtain compelling accuracy improvements when compared to existing works.}
}

@inproceedings{VHPRE,
  author    = {Jean Paul Barddal},
  title     = {Vertical and Horizontal Partitioning in Data Stream Regression Ensembles},
  booktitle = {2019 International Joint Conference on Neural Networks, {IJCNN} 2019,
               Budapest, Hungary, July 14-19, 2019},
  year      = {2019},
  abstract  = {Data stream mining is an emerging topic in machine learning that targets the creation and update of predictive models over time as new data becomes available. Regarding existing works, classification is the most widely tackled task, which leaves regression nearly untouched. In this paper, the focus relies on ensemble learning for data stream regression, more specifically on vertical and horizontal data partitioning techniques. The goal is to determine whether and under which conditions partitioning can lessen the error rates of different types of learners in the data stream regression task. The proposed method combines vertical and horizontal partitioning, and it is compared with and against different types of learners and existing ensembles.}
}

@inproceedings{REGULARIZED_HTS,
  author    = {Jean Paul Barddal and Fabricio Enembreck},
  title     = {Learning Regularized Hoeffding Trees from Data Streams},
  booktitle = {Proceedings of the 34rd Annual {ACM} Symposium on Applied Computing,
               {SAC} 2019, Limassol, Cyprus, April 08-12, 2019},
  year      = {2019},
  abstract = {Learning from data streams is a hot topic in machine learning that targets the learning and update of predictive models as data becomes available for both training and query. Due to their simplicity and convincing results in a multitude of applications, Hoeffding Trees are, by far, the most widely used family of methods for learning decision trees from streaming data. Despite the aforementioned positive characteristics, Hoeffding Trees tend to continuously grow in terms of nodes as new data becomes available, i.e., they eventually split on all features available, and multiple times on the same feature; thus leading to unnecessary complexity. With this behavior, Hoeffding Trees lose the ability to be human-understandable and computationally efficient. To tackle these issues, we propose a regularization scheme for Hoeffding Trees that (i) uses a penalty factor to control the gain obtained by creating a new split node using a feature that has not been used thus far; and (ii) uses information from previous splits in the current branch to determine whether the gain observed indeed justifies a new split. The proposed scheme is combined with both standard and adaptive variants of Hoeffding Trees. Experiments using real-world, stationary and drifting synthetic data show that the proposed method prevents both original and adaptive Hoeffding Trees from unnecessarily growing while maintaining impressive accuracy rates. As a byproduct of the regularization process, significant improvements in processing time, model complexity, and memory consumption have also been observed, thus showing the effectiveness of the proposed regularization scheme.}
}

@inproceedings{KARAX_TREE_FEATURE_IMPORTANCE,
  author    = {Jean Antonio Karax, Andreia Malucelli, and Jean Paul Barddal},
  title     = {Decision tree-based Feature Ranking in Concept Drifting Data Streams},
  booktitle = {Proceedings of the 34rd Annual {ACM} Symposium on Applied Computing,
               {SAC} 2019, Limassol, Cyprus, April 08-12, 2019},
  year      = {2019},
  abstract  = {Data stream mining targets the learning of predictive models that evolve over time according to changes in arriving data. Throughout the years, several approaches have been tailored to create and continuously update predictive models from these streams, and from these, Hoeffding Trees became a popular choice for learning decision trees from data streams. In this paper, we aim at quantifying and expressing the importance of features in dynamic scenarios is of the utmost importance as they allow domain experts to back up, or invalidate, a predictive model. Therefore, we propose and assess a positional gain method tailored for for both individual and ensembles of Hoeffding Trees and how these behave in both synthetic and real-world scenarios.}
}

@article{BARDDAL201913,
title = "Boosting decision stumps for dynamic feature selection on data streams",
journal = "Information Systems",
volume = "83",
pages = "13 - 29",
year = "2019",
issn = "0306-4379",
doi = "https://doi.org/10.1016/j.is.2019.02.003",
url = "http://www.sciencedirect.com/science/article/pii/S0306437918303399",
author = "Jean Paul Barddal and Fabrício Enembreck and Heitor Murilo Gomes and Albert Bifet and Bernhard Pfahringer",
keywords = "Data stream mining, Feature selection, Concept drift, Feature drift",
abstract = "Feature selection targets the identification of which features of a dataset are relevant to the learning task. It is also widely known and used to improve computation times, reduce computation requirements, and to decrease the impact of the curse of dimensionality and enhancing the generalization rates of classifiers. In data streams, classifiers shall benefit from all the items above, but more importantly, from the fact that the relevant subset of features may drift over time. In this paper, we propose a novel dynamic feature selection method for data streams called Adaptive Boosting for Feature Selection (ABFS). ABFS chains decision stumps and drift detectors, and as a result, identifies which features are relevant to the learning task as the stream progresses with reasonable success. In addition to our proposed algorithm, we bring feature selection-specific metrics from batch learning to streaming scenarios. Next, we evaluate ABFS according to these metrics in both synthetic and real-world scenarios. As a result, ABFS improves the classification rates of different types of learners and eventually enhances computational resources usage."
}

@article{DBLP:journals/eswa/BarddalEGBP19,
  author    = {Jean Paul Barddal and
               Fabr{\'{\i}}cio Enembreck and
               Heitor Murilo Gomes and
               Albert Bifet and
               Bernhard Pfahringer},
  title     = {Merit-guided dynamic feature selection filter for data streams},
  journal   = {Expert Syst. Appl.},
  volume    = {116},
  pages     = {227--242},
  year      = {2019},
  url       = {https://doi.org/10.1016/j.eswa.2018.09.031},
  doi       = {10.1016/j.eswa.2018.09.031},
  timestamp = {Fri, 02 Nov 2018 15:38:38 +0100},
  biburl    = {https://dblp.org/rec/bib/journals/eswa/BarddalEGBP19},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract = {Learning from ephemeral data streams has garnered the interest of both researchers and practitioners towards adaptive learning techniques. Despite the convincing results obtained thus far, most of the current research still overlooks that the relevance of features may change throughout the learning process. Scenarios where features become - or cease to be - relevant to the learning task are called feature drifting data streams, and the identification of which features are relevant becomes even more challenging when the feature space is high-dimensional. To select relevant features during the progress of data streams, we propose a merit-guided and classifier-independent dynamic feature selection algorithm named DynamIc SymmetriCal Uncertainty Selection for Streams (DISCUSS). We evaluate our proposal on both synthetic and real-world datasets and show that DISCUSS can boost kNN and Naive Bayes classifiers’ accuracy rates on high-dimensional data streams, while at the expense of limited processing time and memory space. Finally, the drawbacks of the proposed method are assessed, and possible future works on the topic are also discussed.}
}

@inproceedings{DBLP:conf/esann/GomesBFB18,
  author    = {Heitor Murilo Gomes and
               Jean Paul Barddal and
               Luis Eduardo Boiko Ferreira and
               Albert Bifet},
  title     = {Adaptive random forests for data stream regression},
  booktitle = {26th European Symposium on Artificial Neural Networks, {ESANN} 2018,
               Bruges, Belgium, April 25-27, 2018},
  year      = {2018},
  crossref  = {DBLP:conf/esann/2018},
  url       = {http://www.elen.ucl.ac.be/Proceedings/esann/esannpdf/es2018-183.pdf},
  timestamp = {Fri, 09 Nov 2018 12:29:56 +0100},
  biburl    = {https://dblp.org/rec/bib/conf/esann/GomesBFB18},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Data stream mining is a hot topic in the machine learning community that tackles the problem of learning and updating predictive models as new data becomes available over time. Even though several new methods are proposed every year, most focus on the classification task and overlook the regression task. In this paper, we propose an adaptation to the Adaptive Random Forest so that it can handle regression tasks, namely ARF-Reg. ARF-Reg is empirically evaluated and compared to the state-of-the-art data stream regression algorithms, thus highlighting its applicability in different data stream scenarios.}
}

@inproceedings{DBLP:conf/ijcnn/FerreiraBEG18,
  author    = {Luis Eduardo Boiko Ferreira and
               Jean Paul Barddal and
               Fabr{\'{\i}}cio Enembreck and
               Heitor Murilo Gomes},
  title     = {An Experimental Perspective on Sampling Methods for Imbalanced Learning
               From Financial Databases},
  booktitle = {2018 International Joint Conference on Neural Networks, {IJCNN} 2018,
               Rio de Janeiro, Brazil, July 8-13, 2018},
  pages     = {1--6},
  year      = {2018},
  crossref  = {DBLP:conf/ijcnn/2018},
  url       = {https://doi.org/10.1109/IJCNN.2018.8489290},
  doi       = {10.1109/IJCNN.2018.8489290},
  timestamp = {Mon, 22 Oct 2018 13:07:32 +0200},
  biburl    = {https://dblp.org/rec/bib/conf/ijcnn/FerreiraBEG18},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {The financial market is one of the major consumers of data mining techniques, and the main reason is their efficiency to analyze complex data. One important trait shared between most financial applications is class imbalance. Since traditional classification methods assume nearly balanced classes and equal misclassification costs, they usually fail to deal with imbalanced data. However, in financial contexts, problems are usually imbalanced, and instances from the minority class are known for deficits of millions of dollars every year, e.g., credit card frauds, money laundering transactions and so forth. Over the years, several techniques for dealing with class imbalance have been developed, such as sampling techniques and algorithm adaptations. In this study, we analyze how different sampling techniques impact the performance of different classification systems on financial applications. Results show that, for the given datasets, sampling techniques allow the improvement of prediction performance of the minority class while also improving overall classification rates. Nevertheless, their use often deteriorates the performance in predicting the majority class.}
}

@inproceedings{DBLP:conf/indin/SearaMSB18,
  author    = {Marina Ponestke Seara and
               Andreia Malucelli and
               Altair Olivo Santin and
               Jean Paul Barddal},
  title     = {Are fintechs really a hype? {A} machine learning-based polarity analysis
               of Brazilian posts on social media},
  booktitle = {16th {IEEE} International Conference on Industrial Informatics, {INDIN}
               2018, Porto, Portugal, July 18-20, 2018},
  pages     = {233--238},
  year      = {2018},
  crossref  = {DBLP:conf/indin/2018},
  url       = {https://doi.org/10.1109/INDIN.2018.8471986},
  doi       = {10.1109/INDIN.2018.8471986},
  timestamp = {Fri, 12 Oct 2018 10:26:41 +0200},
  biburl    = {https://dblp.org/rec/bib/conf/indin/SearaMSB18},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Fintechs are technology companies that, in contrast to traditional banks, are engaged in digital solutions for payment, money transfers, and real-time notifications. Taking advantage of digital means of communication, most of the service interactions between fintechs and customers occurs via chats or posts in social media. In this work, our goal is to use machine learning to analyze these posts and identify what are the terms used by customers to express positive, neutral and negative customer experiences. During this analysis, we assess the following questions using data from the 3 biggest fintechs in Brazil: (i) what are the most commented topics on social media regarding fintechs, (ii) what are the words more often used by customers to express positive, negative and neutral reactions to the customer service obtained; and (iii) what kind of machine learning model should a fintech use to automatically identify whether a post is positive, negative or neutral.}
}

@inproceedings{DBLP:conf/sac/YuanPB18,
  author    = {Lanqin Yuan and
               Bernhard Pfahringer and
               Jean Paul Barddal},
  title     = {Iterative subset selection for feature drifting data streams},
  booktitle = {Proceedings of the 33rd Annual {ACM} Symposium on Applied Computing,
               {SAC} 2018, Pau, France, April 09-13, 2018},
  pages     = {510--517},
  year      = {2018},
  crossref  = {DBLP:conf/sac/2018},
  url       = {https://doi.org/10.1145/3167132.3167188},
  doi       = {10.1145/3167132.3167188},
  timestamp = {Wed, 21 Nov 2018 12:43:56 +0100},
  biburl    = {https://dblp.org/rec/bib/conf/sac/YuanPB18},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Feature selection has been studied and shown to improve classifier performance in standard batch data mining but is mostly unexplored in data stream mining. Feature selection becomes even more important when the relevant subset of features changes over time, as the underlying concept of a data stream drifts. This specific kind of drift is known as feature drift and requires specific techniques not only to determine which features are the most important but also to take advantage of them. This paper presents a novel method of feature subset selection specialized for dealing with the occurrence of feature drifts called Iterative Subset Selection (ISS), which splits the feature selection process into two stages by first ranking the features, and then iteratively selecting features from the ranking. Applying our feature selection method together with Naive Bayes or k-Nearest Neighbour as a classifier, results in compelling accuracy improvements, compared to prior work.}
}

@article{DBLP:journals/csur/GomesBEB17,
  author    = {Heitor Murilo Gomes and
               Jean Paul Barddal and
               Fabr{\'{\i}}cio Enembreck and
               Albert Bifet},
  title     = {A Survey on Ensemble Learning for Data Stream Classification},
  journal   = {{ACM} Comput. Surv.},
  volume    = {50},
  number    = {2},
  pages     = {23:1--23:36},
  year      = {2017},
  url       = {https://doi.org/10.1145/3054925},
  doi       = {10.1145/3054925},
  timestamp = {Fri, 30 Nov 2018 12:48:46 +0100},
  biburl    = {https://dblp.org/rec/bib/journals/csur/GomesBEB17},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Ensemble-based methods are among the most widely used techniques for data stream classification. Their popularity is attributable to their good performance in comparison to strong single learners while being relatively easy to deploy in real-world applications. Ensemble algorithms are especially useful for data stream learning as they can be integrated with drift detection algorithms and incorporate dynamic updates, such as selective removal or addition of classifiers. This work proposes a taxonomy for data stream ensemble learning as derived from reviewing over 60 algorithms. Important aspects such as combination, diversity, and dynamic updates, are thoroughly discussed. Additional contributions include a listing of popular open-source tools and a discussion about current data stream research challenges and how they relate to ensemble learning (big data streams, concept evolution, feature drifts, temporal dependencies, and others).}
}

@article{DBLP:journals/jss/BarddalGEP17,
  author    = {Jean Paul Barddal and
               Heitor Murilo Gomes and
               Fabr{\'{\i}}cio Enembreck and
               Bernhard Pfahringer},
  title     = {A survey on feature drift adaptation: Definition, benchmark, challenges
               and future directions},
  journal   = {Journal of Systems and Software},
  volume    = {127},
  pages     = {278--294},
  year      = {2017},
  url       = {https://doi.org/10.1016/j.jss.2016.07.005},
  doi       = {10.1016/j.jss.2016.07.005},
  timestamp = {Tue, 06 Jun 2017 22:24:00 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/jss/BarddalGEP17},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Data stream mining is a fast growing research topic due to the ubiquity of data in several real-world problems. Given their ephemeral nature, data stream sources are expected to undergo changes in data distribution, a phenomenon called concept drift. This paper focuses on one specific type of drift that has not yet been thoroughly studied, namely feature drift. Feature drift occurs whenever a subset of features becomes, or ceases to be, relevant to the learning task; thus, learners must detect and adapt to these changes accordingly. We survey existing work on feature drift adaptation with both explicit and implicit approaches. Additionally, we benchmark several algorithms and a naive feature drift detection approach using synthetic and real-world datasets. The results from our experiments indicate the need for future research in this area as even naive approaches produced gains in accuracy while reducing resources usage. Finally, we state current research topics, challenges and future directions for feature drift adaptation.}
}

@article{DBLP:journals/ml/GomesBRBEPHA17,
  author    = {Heitor Murilo Gomes and
               Albert Bifet and
               Jesse Read and
               Jean Paul Barddal and
               Fabr{\'{\i}}cio Enembreck and
               Bernhard Pfharinger and
               Geoff Holmes and
               Talel Abdessalem},
  title     = {Adaptive random forests for evolving data stream classification},
  journal   = {Machine Learning},
  volume    = {106},
  number    = {9-10},
  pages     = {1469--1495},
  year      = {2017},
  url       = {https://doi.org/10.1007/s10994-017-5642-8},
  doi       = {10.1007/s10994-017-5642-8},
  timestamp = {Tue, 26 Jun 2018 14:09:25 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/ml/GomesBRBEPHA17},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Random forests is currently one of the most used machine learning algorithms in the non-streaming (batch) setting. This preference is attributable to its high learning performance and low demands with respect to input preparation and hyper-parameter tuning. However, in the challenging context of evolving data streams, there is no random forests algorithm that can be considered state-of-the-art in comparison to bagging and boosting based algorithms. In this work, we present the adaptive random forest (ARF) algorithm for classification of evolving data streams. In contrast to previous attempts of replicating random forests for data stream learning, ARF includes an effective resampling method and adaptive operators that can cope with different types of concept drifts without complex optimizations for different data sets. We present experiments with a parallel implementation of ARF which has no degradation in terms of classification performance in comparison to a serial implementation, since trees and adaptive operators are independent from one another. Finally, we compare ARF with state-of-the-art algorithms in a traditional test-then-train evaluation and a novel delayed labelling evaluation, and show that ARF is accurate and uses a feasible amount of resources.}
}

@inproceedings{DBLP:conf/ictai/FerreiraBGE17,
  author    = {Luis Eduardo Boiko Ferreira and
               Jean Paul Barddal and
               Heitor Murilo Gomes and
               Fabr{\'{\i}}cio Enembreck},
  title     = {Improving Credit Risk Prediction in Online Peer-to-Peer {(P2P)} Lending
               Using Imbalanced Learning Techniques},
  booktitle = {29th {IEEE} International Conference on Tools with Artificial Intelligence,
               {ICTAI} 2017, Boston, MA, USA, November 6-8, 2017},
  pages     = {175--181},
  year      = {2017},
  crossref  = {DBLP:conf/ictai/2017},
  url       = {https://doi.org/10.1109/ICTAI.2017.00037},
  doi       = {10.1109/ICTAI.2017.00037},
  timestamp = {Tue, 31 Jul 2018 12:20:29 +0200},
  biburl    = {https://dblp.org/rec/bib/conf/ictai/FerreiraBGE17},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Peer-to-peer (P2P) lending is a global trend of financial markets that allow individuals to obtain and concede loans without having financial institutions as a strong proxy. As many real-world applications, P2P lending presents an imbalanced characteristic, where the number of creditworthy loan requests is much larger than the number of non-creditworthy ones. In this work, we wrangle a real-world P2P lending data set from Lending Club, containing a large amount of data gathered from 2007 up to 2016. We analyze how supervised classification models and techniques to handle class imbalance impact creditworthiness prediction rates. Ensembles, cost-sensitive and sampling methods are combined and evaluated along logistic regression, decision tree, and bayesian learning schemes. Results show that, in average, sampling techniques outperform ensembles and cost sensitive approaches.}
}

@article{DBLP:journals/is/BarddalGEB16,
  author    = {Jean Paul Barddal and
               Heitor Murilo Gomes and
               Fabr{\'{\i}}cio Enembreck and
               Jean{-}Paul A. Barth{\`{e}}s},
  title     = {SNCStream+: Extending a high quality true anytime
               data stream clustering algorithm},
  journal   = {Inf. Syst.},
  volume    = {62},
  pages     = {60--73},
  year      = {2016},
  url       = {https://doi.org/10.1016/j.is.2016.06.007},
  doi       = {10.1016/j.is.2016.06.007},
  timestamp = {Tue, 06 Jun 2017 22:22:00 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/is/BarddalGEB16},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Data Stream Clustering is an active area of research which requires efficient algorithms capable of finding and updating clusters incrementally as data arrives. On top of that, due to the inherent evolving nature of data streams, it is expected that algorithms undergo both concept drifts and evolutions, which must be taken into account by the clustering algorithm, allowing incremental clustering updates. In this paper we present the Social Network Clusterer Stream+ (SNCStream+). SNCStream+ tackles the data stream clustering problem as a network formation and evolution problem, where instances and micro-clusters form clusters based on homophily. Our proposal has its parameters analyzed and it is evaluated in a broad set of problems against literature baselines. Results show that SNCStream+ achieves superior clustering quality (CMM), and feasible processing time and memory space usage when compared to the original SNCStream and other proposals of the literature.}
}

@inproceedings{DBLP:conf/icpr/BarddalGBE16,
  author    = {Jean Paul Barddal and
               Heitor Murilo Gomes and
               Alceu de Souza Britto Jr. and
               Fabr{\'{\i}}cio Enembreck},
  title     = {A benchmark of classifiers on feature drifting data streams},
  booktitle = {23rd International Conference on Pattern Recognition, {ICPR} 2016,
               Canc{\'{u}}n, Mexico, December 4-8, 2016},
  pages     = {2180--2185},
  year      = {2016},
  crossref  = {DBLP:conf/icpr/2016},
  url       = {https://doi.org/10.1109/ICPR.2016.7899959},
  doi       = {10.1109/ICPR.2016.7899959},
  timestamp = {Wed, 24 May 2017 08:30:42 +0200},
  biburl    = {https://dblp.org/rec/bib/conf/icpr/BarddalGBE16},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {The ever increasing data generation confronts both practitioners and researchers on handling massive and sequentially generated amounts of information, the so-called data streams. In this context, a lot of effort has been put on the extraction of useful patterns from streaming scenarios. Learning from data streams embeds a variety of problems, and by far, the most challenging is concept drift, i.e. changes in data distribution. In this paper, we focus on a specific type of drift uncommonly assessed in the literature: feature drifts. Feature drifts occur whenever a subset of features becomes, or ceases to be, relevant to the concept to be learned. We propose and review several feature drifting data stream generators and use them to benchmark state-of-the-art data stream classification algorithms and their combination with drift detectors. Results show that, although drift detectors enable slight quicker recovery to feature drifts, best results are obtained by Hoeffding Adaptive Tree, the only learner that performs dynamic feature selection as streams progress.}
}

@inproceedings{DBLP:conf/icpr/BarddalGGBE16,
  author    = {Jean Paul Barddal and
               Heitor Murilo Gomes and
               Jones Granatyr and
               Alceu de Souza Britto Jr. and
               Fabr{\'{\i}}cio Enembreck},
  title     = {Overcoming feature drifts via dynamic feature weighted k-nearest neighbor
               learning},
  booktitle = {23rd International Conference on Pattern Recognition, {ICPR} 2016,
               Canc{\'{u}}n, Mexico, December 4-8, 2016},
  pages     = {2186--2191},
  year      = {2016},
  crossref  = {DBLP:conf/icpr/2016},
  url       = {https://doi.org/10.1109/ICPR.2016.7899960},
  doi       = {10.1109/ICPR.2016.7899960},
  timestamp = {Wed, 24 May 2017 08:30:48 +0200},
  biburl    = {https://dblp.org/rec/bib/conf/icpr/BarddalGGBE16},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Extracting useful knowledge from data streams is problematic, mainly due to changes in their data distribution, a phenomenon named concept drift. Recently, studies have shown that most of existing algorithms for learning from data streams do not encompass techniques for a specific kind of drift: feature drifts. Feature drifts occur when features become, or cease to be, relevant to the learning task. In this paper, we propose an extension to the k-nearest neighbor classifier, so its distances' computations are weighted according to their current discriminative power. On our proposal, the discriminative power of features is given by entropy, which is swiftly computed over a sliding window. Empirical evidence shows that our approach is able to overcome several existing algorithms in accuracy and feature drift adaptation, while at the expense of bounded processing time and memory space.}
}

@inproceedings{DBLP:conf/ijcnn/GranatyrBAEG16,
  author    = {Jones Granatyr and
               Jean Paul Barddal and
               Adriano Weihmayer Almeida and
               Fabr{\'{\i}}cio Enembreck and
               Adaiane Pereira dos Santos Granatyr},
  title     = {Towards emotion-based reputation guessing learning agents},
  booktitle = {2016 International Joint Conference on Neural Networks, {IJCNN} 2016,
               Vancouver, BC, Canada, July 24-29, 2016},
  pages     = {3801--3808},
  year      = {2016},
  crossref  = {DBLP:conf/ijcnn/2016},
  url       = {https://doi.org/10.1109/IJCNN.2016.7727690},
  doi       = {10.1109/IJCNN.2016.7727690},
  timestamp = {Fri, 26 May 2017 00:50:11 +0200},
  biburl    = {https://dblp.org/rec/bib/conf/ijcnn/GranatyrBAEG16},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Trust and reputation mechanisms are part of the logical protection of intelligent agents, preventing malicious agents from acting egotistically or with the intention to damage others. Several studies in Psychology, Neurology and Anthropology claim that emotions are part of human's decision making process. However, there is a lack of understanding about how affective aspects, such as emotions, influence trust or reputation levels of intelligent agents when they are inserted into an information exchange environment, e.g. an evaluation system. In this paper we propose a reputation model that accounts for emotional bounds given by Ekman's basic emotions and inductive machine learning. Our proposal is evaluated by extracting emotions from texts provided by two online human-fed evaluation systems. Empirical results show significant agent's utility improvements with p <; .05 when compared to non-emotion-wise proposals, thus, showing the need for future research in this area.}
}

@inproceedings{DBLP:conf/pkdd/BarddalGEPB16,
  author    = {Jean Paul Barddal and
               Heitor Murilo Gomes and
               Fabr{\'{\i}}cio Enembreck and
               Bernhard Pfahringer and
               Albert Bifet},
  title     = {On Dynamic Feature Weighting for Feature Drifting Data Streams},
  booktitle = {Machine Learning and Knowledge Discovery in Databases - European Conference,
               {ECML} {PKDD} 2016, Riva del Garda, Italy, September 19-23, 2016,
               Proceedings, Part {II}},
  pages     = {129--144},
  year      = {2016},
  crossref  = {DBLP:conf/pkdd/2016-2},
  url       = {https://doi.org/10.1007/978-3-319-46227-1\_9},
  doi       = {10.1007/978-3-319-46227-1\_9},
  timestamp = {Thu, 15 Jun 2017 21:40:02 +0200},
  biburl    = {https://dblp.org/rec/bib/conf/pkdd/BarddalGEPB16},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {The ubiquity of data streams has been encouraging the development of new incremental and adaptive learning algorithms. Data stream learners must be fast, memory-bounded, but mainly, tailored to adapt to possible changes in the data distribution, a phenomenon named concept drift. Recently, several works have shown the impact of a so far nearly neglected type of drifcccct: feature drifts. Feature drifts occur whenever a subset of features becomes, or ceases to be, relevant to the learning task. In this paper we (i) provide insights into how the relevance of features can be tracked as a stream progresses according to information theoretical Symmetrical Uncertainty; and (ii) how it can be used to boost two learning schemes: Naive Bayesian and k-Nearest Neighbor. Furthermore, we investigate the usage of these two new dynamically weighted learners as prediction models in the leaves of the Hoeffding Adaptive Tree classifier. Results show improvements in accuracy (an average of 10.69 % for k-Nearest Neighbor, 6.23 % for Naive Bayes and 4.42 % for Hoeffding Adaptive Trees) in both synthetic and real-world datasets at the expense of a bounded increase in both memory consumption and processing time.}
}

@article{DBLP:journals/ijncr/BarddalGE15,
  author    = {Jean Paul Barddal and
               Heitor Murilo Gomes and
               Fabr{\'{\i}}cio Enembreck},
  title     = {Advances on Concept Drift Detection in Regression Tasks Using Social
               Networks Theory},
  journal   = {{IJNCR}},
  volume    = {5},
  number    = {1},
  pages     = {26--41},
  year      = {2015},
  url       = {https://doi.org/10.4018/ijncr.2015010102},
  doi       = {10.4018/ijncr.2015010102},
  timestamp = {Sun, 28 May 2017 13:18:05 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/ijncr/BarddalGE15},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Mining data streams is one of the main studies in machine learning area due to its application in many knowledge areas. One of the major challenges on mining data streams is concept drift, which requires the learner to discard the current concept and adapt to a new one. Ensemble-based drift detection algorithms have been used successfully to the classification task but usually maintain a fixed size ensemble of learners running the risk of needlessly spending processing time and memory. In this paper the authors present improvements to the Scale-free Network Regressor (SFNR), a dynamic ensemble-based method for regression that employs social networks theory. In order to detect concept drifts SFNR uses the Adaptive Window (ADWIN) algorithm. Results show improvements in accuracy, especially in concept drift situations and better performance compared to other state-of-the-art algorithms in both real and synthetic data.}
}

@inproceedings{DBLP:conf/iceis/SouzaBGBE15,
  author    = {Anderson Jos{\'{e}} de Souza and
               Andr{\'{e}} Pinz Borges and
               Heitor Murilo Gomes and
               Jean Paul Barddal and
               Fabr{\'{\i}}cio Enembreck},
  title     = {Applying Ensemble-based Online Learning Techniques on Crime Forecasting},
  booktitle = {{ICEIS} 2015 - Proceedings of the 17th International Conference on
               Enterprise Information Systems, Volume 1, Barcelona, Spain, 27-30
               April, 2015},
  pages     = {17--24},
  year      = {2015},
  crossref  = {DBLP:conf/iceis/2015-1},
  url       = {https://doi.org/10.5220/0005335700170024},
  doi       = {10.5220/0005335700170024},
  timestamp = {Wed, 17 May 2017 10:54:49 +0200},
  biburl    = {https://dblp.org/rec/bib/conf/iceis/SouzaBGBE15},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Traditional prediction algorithms assume that the underlying concept is stationary, i.e., no changes are expected to happen during the deployment of an algorithm that would render it obsolete. Although, for many real world scenarios changes in the data distribution, namely concept drifts, are expected to occur due to variations in the hidden context, e.g., new government regulations, climatic changes, or adversary adaptation. In this paper, we analyze the problem of predicting the most susceptible types of victims of crimes occurred in a large city of Brazil. It is expected that criminals change their victims' types to counter police methods and vice-versa. Therefore, the challenge is to obtain a model capable of adapting rapidly to the current preferred criminal victims, such that police resources can be allocated accordingly. In this type of problem the most appropriate learning models are provided by data stream mining, since the learning algorithms from this domain assume that concept drifts may occur over time, and are ready to adapt to them. In this paper we apply ensemble-based data stream methods, since they provide good accuracy and the ability to adapt to concept drifts. Results show that the application of these ensemble-based algorithms (Leveraging Bagging, SFNClassifier, ADWIN Bagging and Online Bagging) reach feasible accuracy for this task.}
}

@inproceedings{DBLP:conf/iconip/BarddalGE15,
  author    = {Jean Paul Barddal and
               Heitor Murilo Gomes and
               Fabr{\'{\i}}cio Enembreck},
  title     = {Analyzing the Impact of Feature Drifts in Streaming Learning},
  booktitle = {Neural Information Processing - 22nd International Conference, {ICONIP}
               2015, Istanbul, Turkey, November 9-12, 2015, Proceedings, Part {I}},
  pages     = {21--28},
  year      = {2015},
  crossref  = {DBLP:conf/iconip/2015-1},
  url       = {https://doi.org/10.1007/978-3-319-26532-2\_3},
  doi       = {10.1007/978-3-319-26532-2\_3},
  timestamp = {Sun, 08 Jul 2018 23:29:36 +0200},
  biburl    = {https://dblp.org/rec/bib/conf/iconip/BarddalGE15},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Learning from data streams requires efficient algorithms capable of deriving a model accordingly to the arrival of new instances. Data streams are by definition unbounded sequences of data that are possibly non stationary, i.e. they may undergo changes in data distribution, phenomenon named concept drift. Concept drifts force streaming learning algorithms to detect and adapt to such changes in order to present feasible accuracy throughout time. Nonetheless, most of works presented in the literature do not account for a specific kind of drifts: feature drifts. Feature drifts occur whenever the relevance of an arbitrary attribute changes through time, also impacting the concept to be learned. In this paper we (i) verify the occurrence of feature drift in a publicly available dataset, (ii) present a synthetic data stream generator capable of performing feature drifts and (iii) analyze the impact of this type of drift in stream learning algorithms, enlightening that there is room and the need for dynamic feature selection strategies for data streams.}
}

@inproceedings{DBLP:conf/iconip/GomesCZBM15,
  author    = {Heitor Murilo Gomes and
               Deborah Ribeiro de Carvalho and
               Lourdes Zubieta and
               Jean Paul Barddal and
               Andreia Malucelli},
  title     = {On the Discovery of Time Distance Constrained Temporal Association
               Rules},
  booktitle = {Neural Information Processing - 22nd International Conference, {ICONIP}
               2015, Istanbul, Turkey, November 9-12, 2015, Proceedings, Part {II}},
  pages     = {510--519},
  year      = {2015},
  crossref  = {DBLP:conf/iconip/2015-2},
  url       = {https://doi.org/10.1007/978-3-319-26535-3\_58},
  doi       = {10.1007/978-3-319-26535-3\_58},
  timestamp = {Sun, 08 Jul 2018 23:29:36 +0200},
  biburl    = {https://dblp.org/rec/bib/conf/iconip/GomesCZBM15},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {The increased use of data mining algorithms reflects the need for automatic extraction of knowledge from large volumes of data. This work presents a temporal data mining algorithm that discovers frequent Association Rules from timestamped data. These rules are named Cause-Effect Rules, each represented by a multiset of unordered events (Cause) followed by a singleton event (Effect). Also, a Cause-Effect Rule is valid within an specific constraint that defines the minimum and maximum time distance between its Cause and Effect. Our algorithm was tested on a data set from two hospital emergency departments in Sherbrooke, QC, Canada.}
}

@inproceedings{DBLP:conf/iconip/BarddalGE15a,
  author    = {Jean Paul Barddal and
               Heitor Murilo Gomes and
               Fabr{\'{\i}}cio Enembreck},
  title     = {A Complex Network-Based Anytime Data Stream Clustering Algorithm},
  booktitle = {Neural Information Processing - 22nd International Conference, {ICONIP}
               2015, Istanbul, Turkey, November 9-12, 2015, Proceedings, Part {I}},
  pages     = {615--622},
  year      = {2015},
  crossref  = {DBLP:conf/iconip/2015-1},
  url       = {https://doi.org/10.1007/978-3-319-26532-2\_68},
  doi       = {10.1007/978-3-319-26532-2\_68},
  timestamp = {Sun, 08 Jul 2018 23:29:36 +0200},
  biburl    = {https://dblp.org/rec/bib/conf/iconip/BarddalGE15a},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Data stream mining is an active area of research that poses challenging research problems. In the latter years, a variety of data stream clustering algorithms have been proposed to perform unsupervised learning using a two-step framework. Additionally, dealing with non-stationary, unbounded data streams requires the development of algorithms capable of performing fast and incremental clustering addressing time and memory limitations without jeopardizing clustering quality. In this paper we present CNDenStream, a one-step data stream clustering algorithm capable of finding non-hyper-spherical clusters which, in opposition to other data stream clustering algorithms, is able to maintain updated clusters after the arrival of each instance by using a complex network construction and evolution model based on homophily. Empirical studies show that CNDenStream is able to surpass other algorithms in clustering quality and requires a feasible amount of resources when compared to other algorithms presented in the literature.}
}

@inproceedings{DBLP:conf/ictai/BarddalGE15,
  author    = {Jean Paul Barddal and
               Heitor Murilo Gomes and
               Fabr{\'{\i}}cio Enembreck},
  title     = {A Survey on Feature Drift Adaptation},
  booktitle = {27th {IEEE} International Conference on Tools with Artificial Intelligence,
               {ICTAI} 2015, Vietri sul Mare, Italy, November 9-11, 2015},
  pages     = {1053--1060},
  year      = {2015},
  crossref  = {DBLP:conf/ictai/2015},
  url       = {https://doi.org/10.1109/ICTAI.2015.150},
  doi       = {10.1109/ICTAI.2015.150},
  timestamp = {Fri, 26 May 2017 00:51:05 +0200},
  biburl    = {https://dblp.org/rec/bib/conf/ictai/BarddalGE15},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Data stream mining is a fast growing research topic due to the ubiquity of data in several real-world problems. Given their ephemeral nature, data stream sources are expected to undergo changes in data distribution, a phenomenon called concept drift. This paper focuses on one specific type of drift that has not yet been thoroughly studied, namely feature drift. Feature drift occurs whenever a subset of features becomes, or ceases to be, relevant to the learning task; thus, learners must detect and adapt to these changes accordingly. We survey existing work on feature drift adaptation with both explicit and implicit approaches. Additionally, we benchmark several algorithms and a naive feature drift detection approach using synthetic and real-world datasets. The results from our experiments indicate the need for future research in this area as even naive approaches produced gains in accuracy while reducing resources usage. Finally, we state current research topics, challenges and future directions for feature drift adaptation.}
}

@inproceedings{DBLP:conf/sac/BarddalGE15,
  author    = {Jean Paul Barddal and
               Heitor Murilo Gomes and
               Fabr{\'{\i}}cio Enembreck},
  title     = {SNCStream: a social network-based data stream clustering algorithm},
  booktitle = {Proceedings of the 30th Annual {ACM} Symposium on Applied Computing,
               Salamanca, Spain, April 13-17, 2015},
  pages     = {935--940},
  year      = {2015},
  crossref  = {DBLP:conf/sac/2015},
  url       = {https://doi.org/10.1145/2695664.2695674},
  doi       = {10.1145/2695664.2695674},
  timestamp = {Tue, 06 Nov 2018 11:06:47 +0100},
  biburl    = {https://dblp.org/rec/bib/conf/sac/BarddalGE15},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {Data Stream Clustering is an active area of research which requires efficient algorithms capable of finding and updating clusters incrementally. On top of that, due to the inherent evolving nature of data streams, it is expected that these algorithms manage to quickly adapt to both concept drifts and the appearance and disappearance of clusters. Nevertheless, many of the developed two-step algorithms are only capable of finding hyper-spherical clusters and are highly dependant on parametrization. In this paper we introduce SNCStream, a one-step online clustering algorithm based on Social Networks Theory, which uses homophily to find non-hyper-spherical clusters. Our empirical studies show that SNCStream is able to surpass density-based algorithms in cluster quality and requires feasible amount of resources (time and memory) when compared to other algorithms.}
}

@inproceedings{DBLP:conf/sac/GomesBE15,
  author    = {Heitor Murilo Gomes and
               Jean Paul Barddal and
               Fabr{\'{\i}}cio Enembreck},
  title     = {Pairwise combination of classifiers for ensemble learning on data
               streams},
  booktitle = {Proceedings of the 30th Annual {ACM} Symposium on Applied Computing,
               Salamanca, Spain, April 13-17, 2015},
  pages     = {941--946},
  year      = {2015},
  crossref  = {DBLP:conf/sac/2015},
  url       = {https://doi.org/10.1145/2695664.2695754},
  doi       = {10.1145/2695664.2695754},
  timestamp = {Tue, 06 Nov 2018 11:06:46 +0100},
  biburl    = {https://dblp.org/rec/bib/conf/sac/GomesBE15},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {This work presents two different voting strategies for ensemble learning on data streams based on pairwise combination of component classifiers. Despite efforts to build a diverse ensemble, there is always some degree of overlap between component classifiers models. Our voting strategies are aimed at using these overlaps to support ensemble prediction. We hypothesize that by combining pairs of classifiers it is possible to alleviate incorrect individual predictions that would otherwise negatively impact the overall ensemble decision. The first strategy, Pairwise Accuracy (PA), combines the shared accuracy estimation of all possible pairs in the ensemble, while the second strategy, Pairwise Patterns (PP), record patterns of pairwise decisions during training and use these patterns during prediction. We present empirical results comparing ensemble classifiers with their original voting methods and our proposed methods in both real and synthetic datasets, with and without concept drifts. Our analysis indicates that pairwise voting is able to enhance overall performance for PP, especially on real datasets, and that PA is useful whenever there are noticeable differences in accuracy estimates among ensemble members, which is common during concept drifts.}
}

@inproceedings{DBLP:conf/sac/BarddalGE14,
  author    = {Jean Paul Barddal and
               Heitor Murilo Gomes and
               Fabr{\'{\i}}cio Enembreck},
  title     = {SFNClassifier: a scale-free social network method to handle concept
               drift},
  booktitle = {Symposium on Applied Computing, {SAC} 2014, Gyeongju, Republic of
               Korea - March 24 - 28, 2014},
  pages     = {786--791},
  year      = {2014},
  crossref  = {DBLP:conf/sac/2014},
  url       = {https://doi.org/10.1145/2554850.2554855},
  doi       = {10.1145/2554850.2554855},
  timestamp = {Tue, 06 Nov 2018 11:06:48 +0100},
  biburl    = {https://dblp.org/rec/bib/conf/sac/BarddalGE14},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  abstract  = {In this paper, we present a new ensemble method, the Scale-free Network Classifier (SFNClassifier), that is conceived as a dynamic sized scale-free network. In Data Stream Mining, ensemble-based approaches have been proposed to enhance accuracy and allow fast recovery from concept drift. However, these approaches are based on both update and polling heuristics that do not present good accuracy results in arbitrary domains and do not represent explicitly the similarity between classifiers. The representation of the ensemble as a network allows us to extract centrality metrics, which are used to perform a weighted majority vote, where the weight of a classifier is proportional to its centrality value. Based on empirical studies, we concluded that SFNClassifier has comparable results to other ensemble-learners in terms of accuracy and outperformed the other methods in processing time.}
}

repository: jpbarddal/al-folio

repo_name: jpbarddal/al-folio