repo
stringlengths 7
55
| path
stringlengths 4
223
| func_name
stringlengths 1
134
| original_string
stringlengths 75
104k
| language
stringclasses 1
value | code
stringlengths 75
104k
| code_tokens
listlengths 19
28.4k
| docstring
stringlengths 1
46.9k
| docstring_tokens
listlengths 1
1.97k
| sha
stringlengths 40
40
| url
stringlengths 87
315
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
keon/algorithms
|
algorithms/strings/encode_decode.py
|
encode
|
def encode(strs):
"""Encodes a list of strings to a single string.
:type strs: List[str]
:rtype: str
"""
res = ''
for string in strs.split():
res += str(len(string)) + ":" + string
return res
|
python
|
def encode(strs):
"""Encodes a list of strings to a single string.
:type strs: List[str]
:rtype: str
"""
res = ''
for string in strs.split():
res += str(len(string)) + ":" + string
return res
|
[
"def",
"encode",
"(",
"strs",
")",
":",
"res",
"=",
"''",
"for",
"string",
"in",
"strs",
".",
"split",
"(",
")",
":",
"res",
"+=",
"str",
"(",
"len",
"(",
"string",
")",
")",
"+",
"\":\"",
"+",
"string",
"return",
"res"
] |
Encodes a list of strings to a single string.
:type strs: List[str]
:rtype: str
|
[
"Encodes",
"a",
"list",
"of",
"strings",
"to",
"a",
"single",
"string",
".",
":",
"type",
"strs",
":",
"List",
"[",
"str",
"]",
":",
"rtype",
":",
"str"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/strings/encode_decode.py#L8-L16
|
train
|
keon/algorithms
|
algorithms/strings/encode_decode.py
|
decode
|
def decode(s):
"""Decodes a single string to a list of strings.
:type s: str
:rtype: List[str]
"""
strs = []
i = 0
while i < len(s):
index = s.find(":", i)
size = int(s[i:index])
strs.append(s[index+1: index+1+size])
i = index+1+size
return strs
|
python
|
def decode(s):
"""Decodes a single string to a list of strings.
:type s: str
:rtype: List[str]
"""
strs = []
i = 0
while i < len(s):
index = s.find(":", i)
size = int(s[i:index])
strs.append(s[index+1: index+1+size])
i = index+1+size
return strs
|
[
"def",
"decode",
"(",
"s",
")",
":",
"strs",
"=",
"[",
"]",
"i",
"=",
"0",
"while",
"i",
"<",
"len",
"(",
"s",
")",
":",
"index",
"=",
"s",
".",
"find",
"(",
"\":\"",
",",
"i",
")",
"size",
"=",
"int",
"(",
"s",
"[",
"i",
":",
"index",
"]",
")",
"strs",
".",
"append",
"(",
"s",
"[",
"index",
"+",
"1",
":",
"index",
"+",
"1",
"+",
"size",
"]",
")",
"i",
"=",
"index",
"+",
"1",
"+",
"size",
"return",
"strs"
] |
Decodes a single string to a list of strings.
:type s: str
:rtype: List[str]
|
[
"Decodes",
"a",
"single",
"string",
"to",
"a",
"list",
"of",
"strings",
".",
":",
"type",
"s",
":",
"str",
":",
"rtype",
":",
"List",
"[",
"str",
"]"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/strings/encode_decode.py#L18-L30
|
train
|
keon/algorithms
|
algorithms/matrix/multiply.py
|
multiply
|
def multiply(multiplicand: list, multiplier: list) -> list:
"""
:type A: List[List[int]]
:type B: List[List[int]]
:rtype: List[List[int]]
"""
multiplicand_row, multiplicand_col = len(
multiplicand), len(multiplicand[0])
multiplier_row, multiplier_col = len(multiplier), len(multiplier[0])
if(multiplicand_col != multiplier_row):
raise Exception(
"Multiplicand matrix not compatible with Multiplier matrix.")
# create a result matrix
result = [[0] * multiplier_col for i in range(multiplicand_row)]
for i in range(multiplicand_row):
for j in range(multiplier_col):
for k in range(len(multiplier)):
result[i][j] += multiplicand[i][k] * multiplier[k][j]
return result
|
python
|
def multiply(multiplicand: list, multiplier: list) -> list:
"""
:type A: List[List[int]]
:type B: List[List[int]]
:rtype: List[List[int]]
"""
multiplicand_row, multiplicand_col = len(
multiplicand), len(multiplicand[0])
multiplier_row, multiplier_col = len(multiplier), len(multiplier[0])
if(multiplicand_col != multiplier_row):
raise Exception(
"Multiplicand matrix not compatible with Multiplier matrix.")
# create a result matrix
result = [[0] * multiplier_col for i in range(multiplicand_row)]
for i in range(multiplicand_row):
for j in range(multiplier_col):
for k in range(len(multiplier)):
result[i][j] += multiplicand[i][k] * multiplier[k][j]
return result
|
[
"def",
"multiply",
"(",
"multiplicand",
":",
"list",
",",
"multiplier",
":",
"list",
")",
"->",
"list",
":",
"multiplicand_row",
",",
"multiplicand_col",
"=",
"len",
"(",
"multiplicand",
")",
",",
"len",
"(",
"multiplicand",
"[",
"0",
"]",
")",
"multiplier_row",
",",
"multiplier_col",
"=",
"len",
"(",
"multiplier",
")",
",",
"len",
"(",
"multiplier",
"[",
"0",
"]",
")",
"if",
"(",
"multiplicand_col",
"!=",
"multiplier_row",
")",
":",
"raise",
"Exception",
"(",
"\"Multiplicand matrix not compatible with Multiplier matrix.\"",
")",
"# create a result matrix",
"result",
"=",
"[",
"[",
"0",
"]",
"*",
"multiplier_col",
"for",
"i",
"in",
"range",
"(",
"multiplicand_row",
")",
"]",
"for",
"i",
"in",
"range",
"(",
"multiplicand_row",
")",
":",
"for",
"j",
"in",
"range",
"(",
"multiplier_col",
")",
":",
"for",
"k",
"in",
"range",
"(",
"len",
"(",
"multiplier",
")",
")",
":",
"result",
"[",
"i",
"]",
"[",
"j",
"]",
"+=",
"multiplicand",
"[",
"i",
"]",
"[",
"k",
"]",
"*",
"multiplier",
"[",
"k",
"]",
"[",
"j",
"]",
"return",
"result"
] |
:type A: List[List[int]]
:type B: List[List[int]]
:rtype: List[List[int]]
|
[
":",
"type",
"A",
":",
"List",
"[",
"List",
"[",
"int",
"]]",
":",
"type",
"B",
":",
"List",
"[",
"List",
"[",
"int",
"]]",
":",
"rtype",
":",
"List",
"[",
"List",
"[",
"int",
"]]"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/matrix/multiply.py#L10-L28
|
train
|
keon/algorithms
|
algorithms/maths/combination.py
|
combination
|
def combination(n, r):
"""This function calculates nCr."""
if n == r or r == 0:
return 1
else:
return combination(n-1, r-1) + combination(n-1, r)
|
python
|
def combination(n, r):
"""This function calculates nCr."""
if n == r or r == 0:
return 1
else:
return combination(n-1, r-1) + combination(n-1, r)
|
[
"def",
"combination",
"(",
"n",
",",
"r",
")",
":",
"if",
"n",
"==",
"r",
"or",
"r",
"==",
"0",
":",
"return",
"1",
"else",
":",
"return",
"combination",
"(",
"n",
"-",
"1",
",",
"r",
"-",
"1",
")",
"+",
"combination",
"(",
"n",
"-",
"1",
",",
"r",
")"
] |
This function calculates nCr.
|
[
"This",
"function",
"calculates",
"nCr",
"."
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/maths/combination.py#L1-L6
|
train
|
keon/algorithms
|
algorithms/maths/combination.py
|
combination_memo
|
def combination_memo(n, r):
"""This function calculates nCr using memoization method."""
memo = {}
def recur(n, r):
if n == r or r == 0:
return 1
if (n, r) not in memo:
memo[(n, r)] = recur(n - 1, r - 1) + recur(n - 1, r)
return memo[(n, r)]
return recur(n, r)
|
python
|
def combination_memo(n, r):
"""This function calculates nCr using memoization method."""
memo = {}
def recur(n, r):
if n == r or r == 0:
return 1
if (n, r) not in memo:
memo[(n, r)] = recur(n - 1, r - 1) + recur(n - 1, r)
return memo[(n, r)]
return recur(n, r)
|
[
"def",
"combination_memo",
"(",
"n",
",",
"r",
")",
":",
"memo",
"=",
"{",
"}",
"def",
"recur",
"(",
"n",
",",
"r",
")",
":",
"if",
"n",
"==",
"r",
"or",
"r",
"==",
"0",
":",
"return",
"1",
"if",
"(",
"n",
",",
"r",
")",
"not",
"in",
"memo",
":",
"memo",
"[",
"(",
"n",
",",
"r",
")",
"]",
"=",
"recur",
"(",
"n",
"-",
"1",
",",
"r",
"-",
"1",
")",
"+",
"recur",
"(",
"n",
"-",
"1",
",",
"r",
")",
"return",
"memo",
"[",
"(",
"n",
",",
"r",
")",
"]",
"return",
"recur",
"(",
"n",
",",
"r",
")"
] |
This function calculates nCr using memoization method.
|
[
"This",
"function",
"calculates",
"nCr",
"using",
"memoization",
"method",
"."
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/maths/combination.py#L8-L17
|
train
|
keon/algorithms
|
algorithms/map/is_anagram.py
|
is_anagram
|
def is_anagram(s, t):
"""
:type s: str
:type t: str
:rtype: bool
"""
maps = {}
mapt = {}
for i in s:
maps[i] = maps.get(i, 0) + 1
for i in t:
mapt[i] = mapt.get(i, 0) + 1
return maps == mapt
|
python
|
def is_anagram(s, t):
"""
:type s: str
:type t: str
:rtype: bool
"""
maps = {}
mapt = {}
for i in s:
maps[i] = maps.get(i, 0) + 1
for i in t:
mapt[i] = mapt.get(i, 0) + 1
return maps == mapt
|
[
"def",
"is_anagram",
"(",
"s",
",",
"t",
")",
":",
"maps",
"=",
"{",
"}",
"mapt",
"=",
"{",
"}",
"for",
"i",
"in",
"s",
":",
"maps",
"[",
"i",
"]",
"=",
"maps",
".",
"get",
"(",
"i",
",",
"0",
")",
"+",
"1",
"for",
"i",
"in",
"t",
":",
"mapt",
"[",
"i",
"]",
"=",
"mapt",
".",
"get",
"(",
"i",
",",
"0",
")",
"+",
"1",
"return",
"maps",
"==",
"mapt"
] |
:type s: str
:type t: str
:rtype: bool
|
[
":",
"type",
"s",
":",
"str",
":",
"type",
"t",
":",
"str",
":",
"rtype",
":",
"bool"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/map/is_anagram.py#L17-L29
|
train
|
keon/algorithms
|
algorithms/sort/pancake_sort.py
|
pancake_sort
|
def pancake_sort(arr):
"""
Pancake_sort
Sorting a given array
mutation of selection sort
reference: https://www.geeksforgeeks.org/pancake-sorting/
Overall time complexity : O(N^2)
"""
len_arr = len(arr)
if len_arr <= 1:
return arr
for cur in range(len(arr), 1, -1):
#Finding index of maximum number in arr
index_max = arr.index(max(arr[0:cur]))
if index_max+1 != cur:
#Needs moving
if index_max != 0:
#reverse from 0 to index_max
arr[:index_max+1] = reversed(arr[:index_max+1])
# Reverse list
arr[:cur] = reversed(arr[:cur])
return arr
|
python
|
def pancake_sort(arr):
"""
Pancake_sort
Sorting a given array
mutation of selection sort
reference: https://www.geeksforgeeks.org/pancake-sorting/
Overall time complexity : O(N^2)
"""
len_arr = len(arr)
if len_arr <= 1:
return arr
for cur in range(len(arr), 1, -1):
#Finding index of maximum number in arr
index_max = arr.index(max(arr[0:cur]))
if index_max+1 != cur:
#Needs moving
if index_max != 0:
#reverse from 0 to index_max
arr[:index_max+1] = reversed(arr[:index_max+1])
# Reverse list
arr[:cur] = reversed(arr[:cur])
return arr
|
[
"def",
"pancake_sort",
"(",
"arr",
")",
":",
"len_arr",
"=",
"len",
"(",
"arr",
")",
"if",
"len_arr",
"<=",
"1",
":",
"return",
"arr",
"for",
"cur",
"in",
"range",
"(",
"len",
"(",
"arr",
")",
",",
"1",
",",
"-",
"1",
")",
":",
"#Finding index of maximum number in arr",
"index_max",
"=",
"arr",
".",
"index",
"(",
"max",
"(",
"arr",
"[",
"0",
":",
"cur",
"]",
")",
")",
"if",
"index_max",
"+",
"1",
"!=",
"cur",
":",
"#Needs moving",
"if",
"index_max",
"!=",
"0",
":",
"#reverse from 0 to index_max",
"arr",
"[",
":",
"index_max",
"+",
"1",
"]",
"=",
"reversed",
"(",
"arr",
"[",
":",
"index_max",
"+",
"1",
"]",
")",
"# Reverse list",
"arr",
"[",
":",
"cur",
"]",
"=",
"reversed",
"(",
"arr",
"[",
":",
"cur",
"]",
")",
"return",
"arr"
] |
Pancake_sort
Sorting a given array
mutation of selection sort
reference: https://www.geeksforgeeks.org/pancake-sorting/
Overall time complexity : O(N^2)
|
[
"Pancake_sort",
"Sorting",
"a",
"given",
"array",
"mutation",
"of",
"selection",
"sort"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/sort/pancake_sort.py#L1-L25
|
train
|
keon/algorithms
|
algorithms/queues/zigzagiterator.py
|
ZigZagIterator.next
|
def next(self):
"""
:rtype: int
"""
v=self.queue.pop(0)
ret=v.pop(0)
if v: self.queue.append(v)
return ret
|
python
|
def next(self):
"""
:rtype: int
"""
v=self.queue.pop(0)
ret=v.pop(0)
if v: self.queue.append(v)
return ret
|
[
"def",
"next",
"(",
"self",
")",
":",
"v",
"=",
"self",
".",
"queue",
".",
"pop",
"(",
"0",
")",
"ret",
"=",
"v",
".",
"pop",
"(",
"0",
")",
"if",
"v",
":",
"self",
".",
"queue",
".",
"append",
"(",
"v",
")",
"return",
"ret"
] |
:rtype: int
|
[
":",
"rtype",
":",
"int"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/queues/zigzagiterator.py#L11-L18
|
train
|
keon/algorithms
|
algorithms/dp/buy_sell_stock.py
|
max_profit_naive
|
def max_profit_naive(prices):
"""
:type prices: List[int]
:rtype: int
"""
max_so_far = 0
for i in range(0, len(prices) - 1):
for j in range(i + 1, len(prices)):
max_so_far = max(max_so_far, prices[j] - prices[i])
return max_so_far
|
python
|
def max_profit_naive(prices):
"""
:type prices: List[int]
:rtype: int
"""
max_so_far = 0
for i in range(0, len(prices) - 1):
for j in range(i + 1, len(prices)):
max_so_far = max(max_so_far, prices[j] - prices[i])
return max_so_far
|
[
"def",
"max_profit_naive",
"(",
"prices",
")",
":",
"max_so_far",
"=",
"0",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"prices",
")",
"-",
"1",
")",
":",
"for",
"j",
"in",
"range",
"(",
"i",
"+",
"1",
",",
"len",
"(",
"prices",
")",
")",
":",
"max_so_far",
"=",
"max",
"(",
"max_so_far",
",",
"prices",
"[",
"j",
"]",
"-",
"prices",
"[",
"i",
"]",
")",
"return",
"max_so_far"
] |
:type prices: List[int]
:rtype: int
|
[
":",
"type",
"prices",
":",
"List",
"[",
"int",
"]",
":",
"rtype",
":",
"int"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/dp/buy_sell_stock.py#L24-L33
|
train
|
keon/algorithms
|
algorithms/dp/buy_sell_stock.py
|
max_profit_optimized
|
def max_profit_optimized(prices):
"""
input: [7, 1, 5, 3, 6, 4]
diff : [X, -6, 4, -2, 3, -2]
:type prices: List[int]
:rtype: int
"""
cur_max, max_so_far = 0, 0
for i in range(1, len(prices)):
cur_max = max(0, cur_max + prices[i] - prices[i-1])
max_so_far = max(max_so_far, cur_max)
return max_so_far
|
python
|
def max_profit_optimized(prices):
"""
input: [7, 1, 5, 3, 6, 4]
diff : [X, -6, 4, -2, 3, -2]
:type prices: List[int]
:rtype: int
"""
cur_max, max_so_far = 0, 0
for i in range(1, len(prices)):
cur_max = max(0, cur_max + prices[i] - prices[i-1])
max_so_far = max(max_so_far, cur_max)
return max_so_far
|
[
"def",
"max_profit_optimized",
"(",
"prices",
")",
":",
"cur_max",
",",
"max_so_far",
"=",
"0",
",",
"0",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"prices",
")",
")",
":",
"cur_max",
"=",
"max",
"(",
"0",
",",
"cur_max",
"+",
"prices",
"[",
"i",
"]",
"-",
"prices",
"[",
"i",
"-",
"1",
"]",
")",
"max_so_far",
"=",
"max",
"(",
"max_so_far",
",",
"cur_max",
")",
"return",
"max_so_far"
] |
input: [7, 1, 5, 3, 6, 4]
diff : [X, -6, 4, -2, 3, -2]
:type prices: List[int]
:rtype: int
|
[
"input",
":",
"[",
"7",
"1",
"5",
"3",
"6",
"4",
"]",
"diff",
":",
"[",
"X",
"-",
"6",
"4",
"-",
"2",
"3",
"-",
"2",
"]",
":",
"type",
"prices",
":",
"List",
"[",
"int",
"]",
":",
"rtype",
":",
"int"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/dp/buy_sell_stock.py#L37-L48
|
train
|
keon/algorithms
|
algorithms/strings/first_unique_char.py
|
first_unique_char
|
def first_unique_char(s):
"""
:type s: str
:rtype: int
"""
if (len(s) == 1):
return 0
ban = []
for i in range(len(s)):
if all(s[i] != s[k] for k in range(i + 1, len(s))) == True and s[i] not in ban:
return i
else:
ban.append(s[i])
return -1
|
python
|
def first_unique_char(s):
"""
:type s: str
:rtype: int
"""
if (len(s) == 1):
return 0
ban = []
for i in range(len(s)):
if all(s[i] != s[k] for k in range(i + 1, len(s))) == True and s[i] not in ban:
return i
else:
ban.append(s[i])
return -1
|
[
"def",
"first_unique_char",
"(",
"s",
")",
":",
"if",
"(",
"len",
"(",
"s",
")",
"==",
"1",
")",
":",
"return",
"0",
"ban",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"s",
")",
")",
":",
"if",
"all",
"(",
"s",
"[",
"i",
"]",
"!=",
"s",
"[",
"k",
"]",
"for",
"k",
"in",
"range",
"(",
"i",
"+",
"1",
",",
"len",
"(",
"s",
")",
")",
")",
"==",
"True",
"and",
"s",
"[",
"i",
"]",
"not",
"in",
"ban",
":",
"return",
"i",
"else",
":",
"ban",
".",
"append",
"(",
"s",
"[",
"i",
"]",
")",
"return",
"-",
"1"
] |
:type s: str
:rtype: int
|
[
":",
"type",
"s",
":",
"str",
":",
"rtype",
":",
"int"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/strings/first_unique_char.py#L14-L27
|
train
|
keon/algorithms
|
algorithms/tree/bst/kth_smallest.py
|
Solution.kth_smallest
|
def kth_smallest(self, root, k):
"""
:type root: TreeNode
:type k: int
:rtype: int
"""
count = []
self.helper(root, count)
return count[k-1]
|
python
|
def kth_smallest(self, root, k):
"""
:type root: TreeNode
:type k: int
:rtype: int
"""
count = []
self.helper(root, count)
return count[k-1]
|
[
"def",
"kth_smallest",
"(",
"self",
",",
"root",
",",
"k",
")",
":",
"count",
"=",
"[",
"]",
"self",
".",
"helper",
"(",
"root",
",",
"count",
")",
"return",
"count",
"[",
"k",
"-",
"1",
"]"
] |
:type root: TreeNode
:type k: int
:rtype: int
|
[
":",
"type",
"root",
":",
"TreeNode",
":",
"type",
"k",
":",
"int",
":",
"rtype",
":",
"int"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/tree/bst/kth_smallest.py#L24-L32
|
train
|
keon/algorithms
|
algorithms/strings/int_to_roman.py
|
int_to_roman
|
def int_to_roman(num):
"""
:type num: int
:rtype: str
"""
m = ["", "M", "MM", "MMM"];
c = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"];
x = ["", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"];
i = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"];
return m[num//1000] + c[(num%1000)//100] + x[(num%100)//10] + i[num%10];
|
python
|
def int_to_roman(num):
"""
:type num: int
:rtype: str
"""
m = ["", "M", "MM", "MMM"];
c = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"];
x = ["", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"];
i = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"];
return m[num//1000] + c[(num%1000)//100] + x[(num%100)//10] + i[num%10];
|
[
"def",
"int_to_roman",
"(",
"num",
")",
":",
"m",
"=",
"[",
"\"\"",
",",
"\"M\"",
",",
"\"MM\"",
",",
"\"MMM\"",
"]",
"c",
"=",
"[",
"\"\"",
",",
"\"C\"",
",",
"\"CC\"",
",",
"\"CCC\"",
",",
"\"CD\"",
",",
"\"D\"",
",",
"\"DC\"",
",",
"\"DCC\"",
",",
"\"DCCC\"",
",",
"\"CM\"",
"]",
"x",
"=",
"[",
"\"\"",
",",
"\"X\"",
",",
"\"XX\"",
",",
"\"XXX\"",
",",
"\"XL\"",
",",
"\"L\"",
",",
"\"LX\"",
",",
"\"LXX\"",
",",
"\"LXXX\"",
",",
"\"XC\"",
"]",
"i",
"=",
"[",
"\"\"",
",",
"\"I\"",
",",
"\"II\"",
",",
"\"III\"",
",",
"\"IV\"",
",",
"\"V\"",
",",
"\"VI\"",
",",
"\"VII\"",
",",
"\"VIII\"",
",",
"\"IX\"",
"]",
"return",
"m",
"[",
"num",
"//",
"1000",
"]",
"+",
"c",
"[",
"(",
"num",
"%",
"1000",
")",
"//",
"100",
"]",
"+",
"x",
"[",
"(",
"num",
"%",
"100",
")",
"//",
"10",
"]",
"+",
"i",
"[",
"num",
"%",
"10",
"]"
] |
:type num: int
:rtype: str
|
[
":",
"type",
"num",
":",
"int",
":",
"rtype",
":",
"str"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/strings/int_to_roman.py#L6-L15
|
train
|
keon/algorithms
|
algorithms/stack/longest_abs_path.py
|
length_longest_path
|
def length_longest_path(input):
"""
:type input: str
:rtype: int
"""
curr_len, max_len = 0, 0 # running length and max length
stack = [] # keep track of the name length
for s in input.split('\n'):
print("---------")
print("<path>:", s)
depth = s.count('\t') # the depth of current dir or file
print("depth: ", depth)
print("stack: ", stack)
print("curlen: ", curr_len)
while len(stack) > depth: # go back to the correct depth
curr_len -= stack.pop()
stack.append(len(s.strip('\t'))+1) # 1 is the length of '/'
curr_len += stack[-1] # increase current length
print("stack: ", stack)
print("curlen: ", curr_len)
if '.' in s: # update maxlen only when it is a file
max_len = max(max_len, curr_len-1) # -1 is to minus one '/'
return max_len
|
python
|
def length_longest_path(input):
"""
:type input: str
:rtype: int
"""
curr_len, max_len = 0, 0 # running length and max length
stack = [] # keep track of the name length
for s in input.split('\n'):
print("---------")
print("<path>:", s)
depth = s.count('\t') # the depth of current dir or file
print("depth: ", depth)
print("stack: ", stack)
print("curlen: ", curr_len)
while len(stack) > depth: # go back to the correct depth
curr_len -= stack.pop()
stack.append(len(s.strip('\t'))+1) # 1 is the length of '/'
curr_len += stack[-1] # increase current length
print("stack: ", stack)
print("curlen: ", curr_len)
if '.' in s: # update maxlen only when it is a file
max_len = max(max_len, curr_len-1) # -1 is to minus one '/'
return max_len
|
[
"def",
"length_longest_path",
"(",
"input",
")",
":",
"curr_len",
",",
"max_len",
"=",
"0",
",",
"0",
"# running length and max length",
"stack",
"=",
"[",
"]",
"# keep track of the name length",
"for",
"s",
"in",
"input",
".",
"split",
"(",
"'\\n'",
")",
":",
"print",
"(",
"\"---------\"",
")",
"print",
"(",
"\"<path>:\"",
",",
"s",
")",
"depth",
"=",
"s",
".",
"count",
"(",
"'\\t'",
")",
"# the depth of current dir or file",
"print",
"(",
"\"depth: \"",
",",
"depth",
")",
"print",
"(",
"\"stack: \"",
",",
"stack",
")",
"print",
"(",
"\"curlen: \"",
",",
"curr_len",
")",
"while",
"len",
"(",
"stack",
")",
">",
"depth",
":",
"# go back to the correct depth",
"curr_len",
"-=",
"stack",
".",
"pop",
"(",
")",
"stack",
".",
"append",
"(",
"len",
"(",
"s",
".",
"strip",
"(",
"'\\t'",
")",
")",
"+",
"1",
")",
"# 1 is the length of '/'",
"curr_len",
"+=",
"stack",
"[",
"-",
"1",
"]",
"# increase current length",
"print",
"(",
"\"stack: \"",
",",
"stack",
")",
"print",
"(",
"\"curlen: \"",
",",
"curr_len",
")",
"if",
"'.'",
"in",
"s",
":",
"# update maxlen only when it is a file",
"max_len",
"=",
"max",
"(",
"max_len",
",",
"curr_len",
"-",
"1",
")",
"# -1 is to minus one '/'",
"return",
"max_len"
] |
:type input: str
:rtype: int
|
[
":",
"type",
"input",
":",
"str",
":",
"rtype",
":",
"int"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/stack/longest_abs_path.py#L36-L58
|
train
|
keon/algorithms
|
algorithms/matrix/sparse_mul.py
|
multiply
|
def multiply(self, a, b):
"""
:type A: List[List[int]]
:type B: List[List[int]]
:rtype: List[List[int]]
"""
if a is None or b is None: return None
m, n, l = len(a), len(b[0]), len(b[0])
if len(b) != n:
raise Exception("A's column number must be equal to B's row number.")
c = [[0 for _ in range(l)] for _ in range(m)]
for i, row in enumerate(a):
for k, eleA in enumerate(row):
if eleA:
for j, eleB in enumerate(b[k]):
if eleB: c[i][j] += eleA * eleB
return c
|
python
|
def multiply(self, a, b):
"""
:type A: List[List[int]]
:type B: List[List[int]]
:rtype: List[List[int]]
"""
if a is None or b is None: return None
m, n, l = len(a), len(b[0]), len(b[0])
if len(b) != n:
raise Exception("A's column number must be equal to B's row number.")
c = [[0 for _ in range(l)] for _ in range(m)]
for i, row in enumerate(a):
for k, eleA in enumerate(row):
if eleA:
for j, eleB in enumerate(b[k]):
if eleB: c[i][j] += eleA * eleB
return c
|
[
"def",
"multiply",
"(",
"self",
",",
"a",
",",
"b",
")",
":",
"if",
"a",
"is",
"None",
"or",
"b",
"is",
"None",
":",
"return",
"None",
"m",
",",
"n",
",",
"l",
"=",
"len",
"(",
"a",
")",
",",
"len",
"(",
"b",
"[",
"0",
"]",
")",
",",
"len",
"(",
"b",
"[",
"0",
"]",
")",
"if",
"len",
"(",
"b",
")",
"!=",
"n",
":",
"raise",
"Exception",
"(",
"\"A's column number must be equal to B's row number.\"",
")",
"c",
"=",
"[",
"[",
"0",
"for",
"_",
"in",
"range",
"(",
"l",
")",
"]",
"for",
"_",
"in",
"range",
"(",
"m",
")",
"]",
"for",
"i",
",",
"row",
"in",
"enumerate",
"(",
"a",
")",
":",
"for",
"k",
",",
"eleA",
"in",
"enumerate",
"(",
"row",
")",
":",
"if",
"eleA",
":",
"for",
"j",
",",
"eleB",
"in",
"enumerate",
"(",
"b",
"[",
"k",
"]",
")",
":",
"if",
"eleB",
":",
"c",
"[",
"i",
"]",
"[",
"j",
"]",
"+=",
"eleA",
"*",
"eleB",
"return",
"c"
] |
:type A: List[List[int]]
:type B: List[List[int]]
:rtype: List[List[int]]
|
[
":",
"type",
"A",
":",
"List",
"[",
"List",
"[",
"int",
"]]",
":",
"type",
"B",
":",
"List",
"[",
"List",
"[",
"int",
"]]",
":",
"rtype",
":",
"List",
"[",
"List",
"[",
"int",
"]]"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/matrix/sparse_mul.py#L27-L43
|
train
|
keon/algorithms
|
algorithms/matrix/sparse_mul.py
|
multiply
|
def multiply(self, a, b):
"""
:type A: List[List[int]]
:type B: List[List[int]]
:rtype: List[List[int]]
"""
if a is None or b is None: return None
m, n = len(a), len(b[0])
if len(b) != n:
raise Exception("A's column number must be equal to B's row number.")
l = len(b[0])
table_a, table_b = {}, {}
for i, row in enumerate(a):
for j, ele in enumerate(row):
if ele:
if i not in table_a: table_a[i] = {}
table_a[i][j] = ele
for i, row in enumerate(b):
for j, ele in enumerate(row):
if ele:
if i not in table_b: table_b[i] = {}
table_b[i][j] = ele
c = [[0 for j in range(l)] for i in range(m)]
for i in table_a:
for k in table_a[i]:
if k not in table_b: continue
for j in table_b[k]:
c[i][j] += table_a[i][k] * table_b[k][j]
return c
|
python
|
def multiply(self, a, b):
"""
:type A: List[List[int]]
:type B: List[List[int]]
:rtype: List[List[int]]
"""
if a is None or b is None: return None
m, n = len(a), len(b[0])
if len(b) != n:
raise Exception("A's column number must be equal to B's row number.")
l = len(b[0])
table_a, table_b = {}, {}
for i, row in enumerate(a):
for j, ele in enumerate(row):
if ele:
if i not in table_a: table_a[i] = {}
table_a[i][j] = ele
for i, row in enumerate(b):
for j, ele in enumerate(row):
if ele:
if i not in table_b: table_b[i] = {}
table_b[i][j] = ele
c = [[0 for j in range(l)] for i in range(m)]
for i in table_a:
for k in table_a[i]:
if k not in table_b: continue
for j in table_b[k]:
c[i][j] += table_a[i][k] * table_b[k][j]
return c
|
[
"def",
"multiply",
"(",
"self",
",",
"a",
",",
"b",
")",
":",
"if",
"a",
"is",
"None",
"or",
"b",
"is",
"None",
":",
"return",
"None",
"m",
",",
"n",
"=",
"len",
"(",
"a",
")",
",",
"len",
"(",
"b",
"[",
"0",
"]",
")",
"if",
"len",
"(",
"b",
")",
"!=",
"n",
":",
"raise",
"Exception",
"(",
"\"A's column number must be equal to B's row number.\"",
")",
"l",
"=",
"len",
"(",
"b",
"[",
"0",
"]",
")",
"table_a",
",",
"table_b",
"=",
"{",
"}",
",",
"{",
"}",
"for",
"i",
",",
"row",
"in",
"enumerate",
"(",
"a",
")",
":",
"for",
"j",
",",
"ele",
"in",
"enumerate",
"(",
"row",
")",
":",
"if",
"ele",
":",
"if",
"i",
"not",
"in",
"table_a",
":",
"table_a",
"[",
"i",
"]",
"=",
"{",
"}",
"table_a",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"ele",
"for",
"i",
",",
"row",
"in",
"enumerate",
"(",
"b",
")",
":",
"for",
"j",
",",
"ele",
"in",
"enumerate",
"(",
"row",
")",
":",
"if",
"ele",
":",
"if",
"i",
"not",
"in",
"table_b",
":",
"table_b",
"[",
"i",
"]",
"=",
"{",
"}",
"table_b",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"ele",
"c",
"=",
"[",
"[",
"0",
"for",
"j",
"in",
"range",
"(",
"l",
")",
"]",
"for",
"i",
"in",
"range",
"(",
"m",
")",
"]",
"for",
"i",
"in",
"table_a",
":",
"for",
"k",
"in",
"table_a",
"[",
"i",
"]",
":",
"if",
"k",
"not",
"in",
"table_b",
":",
"continue",
"for",
"j",
"in",
"table_b",
"[",
"k",
"]",
":",
"c",
"[",
"i",
"]",
"[",
"j",
"]",
"+=",
"table_a",
"[",
"i",
"]",
"[",
"k",
"]",
"*",
"table_b",
"[",
"k",
"]",
"[",
"j",
"]",
"return",
"c"
] |
:type A: List[List[int]]
:type B: List[List[int]]
:rtype: List[List[int]]
|
[
":",
"type",
"A",
":",
"List",
"[",
"List",
"[",
"int",
"]]",
":",
"type",
"B",
":",
"List",
"[",
"List",
"[",
"int",
"]]",
":",
"rtype",
":",
"List",
"[",
"List",
"[",
"int",
"]]"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/matrix/sparse_mul.py#L71-L99
|
train
|
keon/algorithms
|
algorithms/sort/bitonic_sort.py
|
bitonic_sort
|
def bitonic_sort(arr, reverse=False):
"""
bitonic sort is sorting algorithm to use multiple process, but this code not containing parallel process
It can sort only array that sizes power of 2
It can sort array in both increasing order and decreasing order by giving argument true(increasing) and false(decreasing)
Worst-case in parallel: O(log(n)^2)
Worst-case in non-parallel: O(nlog(n)^2)
reference: https://en.wikipedia.org/wiki/Bitonic_sorter
"""
def compare(arr, reverse):
n = len(arr)//2
for i in range(n):
if reverse != (arr[i] > arr[i+n]):
arr[i], arr[i+n] = arr[i+n], arr[i]
return arr
def bitonic_merge(arr, reverse):
n = len(arr)
if n <= 1:
return arr
arr = compare(arr, reverse)
left = bitonic_merge(arr[:n // 2], reverse)
right = bitonic_merge(arr[n // 2:], reverse)
return left + right
#end of function(compare and bitionic_merge) definition
n = len(arr)
if n <= 1:
return arr
# checks if n is power of two
if not (n and (not(n & (n - 1))) ):
raise ValueError("the size of input should be power of two")
left = bitonic_sort(arr[:n // 2], True)
right = bitonic_sort(arr[n // 2:], False)
arr = bitonic_merge(left + right, reverse)
return arr
|
python
|
def bitonic_sort(arr, reverse=False):
"""
bitonic sort is sorting algorithm to use multiple process, but this code not containing parallel process
It can sort only array that sizes power of 2
It can sort array in both increasing order and decreasing order by giving argument true(increasing) and false(decreasing)
Worst-case in parallel: O(log(n)^2)
Worst-case in non-parallel: O(nlog(n)^2)
reference: https://en.wikipedia.org/wiki/Bitonic_sorter
"""
def compare(arr, reverse):
n = len(arr)//2
for i in range(n):
if reverse != (arr[i] > arr[i+n]):
arr[i], arr[i+n] = arr[i+n], arr[i]
return arr
def bitonic_merge(arr, reverse):
n = len(arr)
if n <= 1:
return arr
arr = compare(arr, reverse)
left = bitonic_merge(arr[:n // 2], reverse)
right = bitonic_merge(arr[n // 2:], reverse)
return left + right
#end of function(compare and bitionic_merge) definition
n = len(arr)
if n <= 1:
return arr
# checks if n is power of two
if not (n and (not(n & (n - 1))) ):
raise ValueError("the size of input should be power of two")
left = bitonic_sort(arr[:n // 2], True)
right = bitonic_sort(arr[n // 2:], False)
arr = bitonic_merge(left + right, reverse)
return arr
|
[
"def",
"bitonic_sort",
"(",
"arr",
",",
"reverse",
"=",
"False",
")",
":",
"def",
"compare",
"(",
"arr",
",",
"reverse",
")",
":",
"n",
"=",
"len",
"(",
"arr",
")",
"//",
"2",
"for",
"i",
"in",
"range",
"(",
"n",
")",
":",
"if",
"reverse",
"!=",
"(",
"arr",
"[",
"i",
"]",
">",
"arr",
"[",
"i",
"+",
"n",
"]",
")",
":",
"arr",
"[",
"i",
"]",
",",
"arr",
"[",
"i",
"+",
"n",
"]",
"=",
"arr",
"[",
"i",
"+",
"n",
"]",
",",
"arr",
"[",
"i",
"]",
"return",
"arr",
"def",
"bitonic_merge",
"(",
"arr",
",",
"reverse",
")",
":",
"n",
"=",
"len",
"(",
"arr",
")",
"if",
"n",
"<=",
"1",
":",
"return",
"arr",
"arr",
"=",
"compare",
"(",
"arr",
",",
"reverse",
")",
"left",
"=",
"bitonic_merge",
"(",
"arr",
"[",
":",
"n",
"//",
"2",
"]",
",",
"reverse",
")",
"right",
"=",
"bitonic_merge",
"(",
"arr",
"[",
"n",
"//",
"2",
":",
"]",
",",
"reverse",
")",
"return",
"left",
"+",
"right",
"#end of function(compare and bitionic_merge) definition",
"n",
"=",
"len",
"(",
"arr",
")",
"if",
"n",
"<=",
"1",
":",
"return",
"arr",
"# checks if n is power of two",
"if",
"not",
"(",
"n",
"and",
"(",
"not",
"(",
"n",
"&",
"(",
"n",
"-",
"1",
")",
")",
")",
")",
":",
"raise",
"ValueError",
"(",
"\"the size of input should be power of two\"",
")",
"left",
"=",
"bitonic_sort",
"(",
"arr",
"[",
":",
"n",
"//",
"2",
"]",
",",
"True",
")",
"right",
"=",
"bitonic_sort",
"(",
"arr",
"[",
"n",
"//",
"2",
":",
"]",
",",
"False",
")",
"arr",
"=",
"bitonic_merge",
"(",
"left",
"+",
"right",
",",
"reverse",
")",
"return",
"arr"
] |
bitonic sort is sorting algorithm to use multiple process, but this code not containing parallel process
It can sort only array that sizes power of 2
It can sort array in both increasing order and decreasing order by giving argument true(increasing) and false(decreasing)
Worst-case in parallel: O(log(n)^2)
Worst-case in non-parallel: O(nlog(n)^2)
reference: https://en.wikipedia.org/wiki/Bitonic_sorter
|
[
"bitonic",
"sort",
"is",
"sorting",
"algorithm",
"to",
"use",
"multiple",
"process",
"but",
"this",
"code",
"not",
"containing",
"parallel",
"process",
"It",
"can",
"sort",
"only",
"array",
"that",
"sizes",
"power",
"of",
"2",
"It",
"can",
"sort",
"array",
"in",
"both",
"increasing",
"order",
"and",
"decreasing",
"order",
"by",
"giving",
"argument",
"true",
"(",
"increasing",
")",
"and",
"false",
"(",
"decreasing",
")",
"Worst",
"-",
"case",
"in",
"parallel",
":",
"O",
"(",
"log",
"(",
"n",
")",
"^2",
")",
"Worst",
"-",
"case",
"in",
"non",
"-",
"parallel",
":",
"O",
"(",
"nlog",
"(",
"n",
")",
"^2",
")",
"reference",
":",
"https",
":",
"//",
"en",
".",
"wikipedia",
".",
"org",
"/",
"wiki",
"/",
"Bitonic_sorter"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/sort/bitonic_sort.py#L1-L43
|
train
|
keon/algorithms
|
algorithms/graph/satisfiability.py
|
scc
|
def scc(graph):
''' Computes the strongly connected components of a graph '''
order = []
vis = {vertex: False for vertex in graph}
graph_transposed = {vertex: [] for vertex in graph}
for (v, neighbours) in graph.iteritems():
for u in neighbours:
add_edge(graph_transposed, u, v)
for v in graph:
if not vis[v]:
dfs_transposed(v, graph_transposed, order, vis)
vis = {vertex: False for vertex in graph}
vertex_scc = {}
current_comp = 0
for v in reversed(order):
if not vis[v]:
# Each dfs will visit exactly one component
dfs(v, current_comp, vertex_scc, graph, vis)
current_comp += 1
return vertex_scc
|
python
|
def scc(graph):
''' Computes the strongly connected components of a graph '''
order = []
vis = {vertex: False for vertex in graph}
graph_transposed = {vertex: [] for vertex in graph}
for (v, neighbours) in graph.iteritems():
for u in neighbours:
add_edge(graph_transposed, u, v)
for v in graph:
if not vis[v]:
dfs_transposed(v, graph_transposed, order, vis)
vis = {vertex: False for vertex in graph}
vertex_scc = {}
current_comp = 0
for v in reversed(order):
if not vis[v]:
# Each dfs will visit exactly one component
dfs(v, current_comp, vertex_scc, graph, vis)
current_comp += 1
return vertex_scc
|
[
"def",
"scc",
"(",
"graph",
")",
":",
"order",
"=",
"[",
"]",
"vis",
"=",
"{",
"vertex",
":",
"False",
"for",
"vertex",
"in",
"graph",
"}",
"graph_transposed",
"=",
"{",
"vertex",
":",
"[",
"]",
"for",
"vertex",
"in",
"graph",
"}",
"for",
"(",
"v",
",",
"neighbours",
")",
"in",
"graph",
".",
"iteritems",
"(",
")",
":",
"for",
"u",
"in",
"neighbours",
":",
"add_edge",
"(",
"graph_transposed",
",",
"u",
",",
"v",
")",
"for",
"v",
"in",
"graph",
":",
"if",
"not",
"vis",
"[",
"v",
"]",
":",
"dfs_transposed",
"(",
"v",
",",
"graph_transposed",
",",
"order",
",",
"vis",
")",
"vis",
"=",
"{",
"vertex",
":",
"False",
"for",
"vertex",
"in",
"graph",
"}",
"vertex_scc",
"=",
"{",
"}",
"current_comp",
"=",
"0",
"for",
"v",
"in",
"reversed",
"(",
"order",
")",
":",
"if",
"not",
"vis",
"[",
"v",
"]",
":",
"# Each dfs will visit exactly one component",
"dfs",
"(",
"v",
",",
"current_comp",
",",
"vertex_scc",
",",
"graph",
",",
"vis",
")",
"current_comp",
"+=",
"1",
"return",
"vertex_scc"
] |
Computes the strongly connected components of a graph
|
[
"Computes",
"the",
"strongly",
"connected",
"components",
"of",
"a",
"graph"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/graph/satisfiability.py#L49-L74
|
train
|
keon/algorithms
|
algorithms/graph/satisfiability.py
|
build_graph
|
def build_graph(formula):
''' Builds the implication graph from the formula '''
graph = {}
for clause in formula:
for (lit, _) in clause:
for neg in [False, True]:
graph[(lit, neg)] = []
for ((a_lit, a_neg), (b_lit, b_neg)) in formula:
add_edge(graph, (a_lit, a_neg), (b_lit, not b_neg))
add_edge(graph, (b_lit, b_neg), (a_lit, not a_neg))
return graph
|
python
|
def build_graph(formula):
''' Builds the implication graph from the formula '''
graph = {}
for clause in formula:
for (lit, _) in clause:
for neg in [False, True]:
graph[(lit, neg)] = []
for ((a_lit, a_neg), (b_lit, b_neg)) in formula:
add_edge(graph, (a_lit, a_neg), (b_lit, not b_neg))
add_edge(graph, (b_lit, b_neg), (a_lit, not a_neg))
return graph
|
[
"def",
"build_graph",
"(",
"formula",
")",
":",
"graph",
"=",
"{",
"}",
"for",
"clause",
"in",
"formula",
":",
"for",
"(",
"lit",
",",
"_",
")",
"in",
"clause",
":",
"for",
"neg",
"in",
"[",
"False",
",",
"True",
"]",
":",
"graph",
"[",
"(",
"lit",
",",
"neg",
")",
"]",
"=",
"[",
"]",
"for",
"(",
"(",
"a_lit",
",",
"a_neg",
")",
",",
"(",
"b_lit",
",",
"b_neg",
")",
")",
"in",
"formula",
":",
"add_edge",
"(",
"graph",
",",
"(",
"a_lit",
",",
"a_neg",
")",
",",
"(",
"b_lit",
",",
"not",
"b_neg",
")",
")",
"add_edge",
"(",
"graph",
",",
"(",
"b_lit",
",",
"b_neg",
")",
",",
"(",
"a_lit",
",",
"not",
"a_neg",
")",
")",
"return",
"graph"
] |
Builds the implication graph from the formula
|
[
"Builds",
"the",
"implication",
"graph",
"from",
"the",
"formula"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/graph/satisfiability.py#L77-L90
|
train
|
keon/algorithms
|
algorithms/backtrack/array_sum_combinations.py
|
unique_array_sum_combinations
|
def unique_array_sum_combinations(A, B, C, target):
"""
1. Sort all the arrays - a,b,c. - This improves average time complexity.
2. If c[i] < Sum, then look for Sum - c[i] in array a and b.
When pair found, insert c[i], a[j] & b[k] into the result list.
This can be done in O(n).
3. Keep on doing the above procedure while going through complete c array.
Complexity: O(n(m+p))
"""
def check_sum(n, *nums):
if sum(x for x in nums) == n:
return (True, nums)
else:
return (False, nums)
pro = itertools.product(A, B, C)
func = partial(check_sum, target)
sums = list(itertools.starmap(func, pro))
res = set()
for s in sums:
if s[0] is True and s[1] not in res:
res.add(s[1])
return list(res)
|
python
|
def unique_array_sum_combinations(A, B, C, target):
"""
1. Sort all the arrays - a,b,c. - This improves average time complexity.
2. If c[i] < Sum, then look for Sum - c[i] in array a and b.
When pair found, insert c[i], a[j] & b[k] into the result list.
This can be done in O(n).
3. Keep on doing the above procedure while going through complete c array.
Complexity: O(n(m+p))
"""
def check_sum(n, *nums):
if sum(x for x in nums) == n:
return (True, nums)
else:
return (False, nums)
pro = itertools.product(A, B, C)
func = partial(check_sum, target)
sums = list(itertools.starmap(func, pro))
res = set()
for s in sums:
if s[0] is True and s[1] not in res:
res.add(s[1])
return list(res)
|
[
"def",
"unique_array_sum_combinations",
"(",
"A",
",",
"B",
",",
"C",
",",
"target",
")",
":",
"def",
"check_sum",
"(",
"n",
",",
"*",
"nums",
")",
":",
"if",
"sum",
"(",
"x",
"for",
"x",
"in",
"nums",
")",
"==",
"n",
":",
"return",
"(",
"True",
",",
"nums",
")",
"else",
":",
"return",
"(",
"False",
",",
"nums",
")",
"pro",
"=",
"itertools",
".",
"product",
"(",
"A",
",",
"B",
",",
"C",
")",
"func",
"=",
"partial",
"(",
"check_sum",
",",
"target",
")",
"sums",
"=",
"list",
"(",
"itertools",
".",
"starmap",
"(",
"func",
",",
"pro",
")",
")",
"res",
"=",
"set",
"(",
")",
"for",
"s",
"in",
"sums",
":",
"if",
"s",
"[",
"0",
"]",
"is",
"True",
"and",
"s",
"[",
"1",
"]",
"not",
"in",
"res",
":",
"res",
".",
"add",
"(",
"s",
"[",
"1",
"]",
")",
"return",
"list",
"(",
"res",
")"
] |
1. Sort all the arrays - a,b,c. - This improves average time complexity.
2. If c[i] < Sum, then look for Sum - c[i] in array a and b.
When pair found, insert c[i], a[j] & b[k] into the result list.
This can be done in O(n).
3. Keep on doing the above procedure while going through complete c array.
Complexity: O(n(m+p))
|
[
"1",
".",
"Sort",
"all",
"the",
"arrays",
"-",
"a",
"b",
"c",
".",
"-",
"This",
"improves",
"average",
"time",
"complexity",
".",
"2",
".",
"If",
"c",
"[",
"i",
"]",
"<",
"Sum",
"then",
"look",
"for",
"Sum",
"-",
"c",
"[",
"i",
"]",
"in",
"array",
"a",
"and",
"b",
".",
"When",
"pair",
"found",
"insert",
"c",
"[",
"i",
"]",
"a",
"[",
"j",
"]",
"&",
"b",
"[",
"k",
"]",
"into",
"the",
"result",
"list",
".",
"This",
"can",
"be",
"done",
"in",
"O",
"(",
"n",
")",
".",
"3",
".",
"Keep",
"on",
"doing",
"the",
"above",
"procedure",
"while",
"going",
"through",
"complete",
"c",
"array",
"."
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/backtrack/array_sum_combinations.py#L59-L84
|
train
|
keon/algorithms
|
algorithms/tree/bst/is_bst.py
|
is_bst
|
def is_bst(root):
"""
:type root: TreeNode
:rtype: bool
"""
stack = []
pre = None
while root or stack:
while root:
stack.append(root)
root = root.left
root = stack.pop()
if pre and root.val <= pre.val:
return False
pre = root
root = root.right
return True
|
python
|
def is_bst(root):
"""
:type root: TreeNode
:rtype: bool
"""
stack = []
pre = None
while root or stack:
while root:
stack.append(root)
root = root.left
root = stack.pop()
if pre and root.val <= pre.val:
return False
pre = root
root = root.right
return True
|
[
"def",
"is_bst",
"(",
"root",
")",
":",
"stack",
"=",
"[",
"]",
"pre",
"=",
"None",
"while",
"root",
"or",
"stack",
":",
"while",
"root",
":",
"stack",
".",
"append",
"(",
"root",
")",
"root",
"=",
"root",
".",
"left",
"root",
"=",
"stack",
".",
"pop",
"(",
")",
"if",
"pre",
"and",
"root",
".",
"val",
"<=",
"pre",
".",
"val",
":",
"return",
"False",
"pre",
"=",
"root",
"root",
"=",
"root",
".",
"right",
"return",
"True"
] |
:type root: TreeNode
:rtype: bool
|
[
":",
"type",
"root",
":",
"TreeNode",
":",
"rtype",
":",
"bool"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/tree/bst/is_bst.py#L23-L42
|
train
|
keon/algorithms
|
algorithms/tree/is_balanced.py
|
__get_depth
|
def __get_depth(root):
"""
return 0 if unbalanced else depth + 1
"""
if root is None:
return 0
left = __get_depth(root.left)
right = __get_depth(root.right)
if abs(left-right) > 1 or -1 in [left, right]:
return -1
return 1 + max(left, right)
|
python
|
def __get_depth(root):
"""
return 0 if unbalanced else depth + 1
"""
if root is None:
return 0
left = __get_depth(root.left)
right = __get_depth(root.right)
if abs(left-right) > 1 or -1 in [left, right]:
return -1
return 1 + max(left, right)
|
[
"def",
"__get_depth",
"(",
"root",
")",
":",
"if",
"root",
"is",
"None",
":",
"return",
"0",
"left",
"=",
"__get_depth",
"(",
"root",
".",
"left",
")",
"right",
"=",
"__get_depth",
"(",
"root",
".",
"right",
")",
"if",
"abs",
"(",
"left",
"-",
"right",
")",
">",
"1",
"or",
"-",
"1",
"in",
"[",
"left",
",",
"right",
"]",
":",
"return",
"-",
"1",
"return",
"1",
"+",
"max",
"(",
"left",
",",
"right",
")"
] |
return 0 if unbalanced else depth + 1
|
[
"return",
"0",
"if",
"unbalanced",
"else",
"depth",
"+",
"1"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/tree/is_balanced.py#L12-L22
|
train
|
keon/algorithms
|
algorithms/linkedlist/copy_random_pointer.py
|
copy_random_pointer_v1
|
def copy_random_pointer_v1(head):
"""
:type head: RandomListNode
:rtype: RandomListNode
"""
dic = dict()
m = n = head
while m:
dic[m] = RandomListNode(m.label)
m = m.next
while n:
dic[n].next = dic.get(n.next)
dic[n].random = dic.get(n.random)
n = n.next
return dic.get(head)
|
python
|
def copy_random_pointer_v1(head):
"""
:type head: RandomListNode
:rtype: RandomListNode
"""
dic = dict()
m = n = head
while m:
dic[m] = RandomListNode(m.label)
m = m.next
while n:
dic[n].next = dic.get(n.next)
dic[n].random = dic.get(n.random)
n = n.next
return dic.get(head)
|
[
"def",
"copy_random_pointer_v1",
"(",
"head",
")",
":",
"dic",
"=",
"dict",
"(",
")",
"m",
"=",
"n",
"=",
"head",
"while",
"m",
":",
"dic",
"[",
"m",
"]",
"=",
"RandomListNode",
"(",
"m",
".",
"label",
")",
"m",
"=",
"m",
".",
"next",
"while",
"n",
":",
"dic",
"[",
"n",
"]",
".",
"next",
"=",
"dic",
".",
"get",
"(",
"n",
".",
"next",
")",
"dic",
"[",
"n",
"]",
".",
"random",
"=",
"dic",
".",
"get",
"(",
"n",
".",
"random",
")",
"n",
"=",
"n",
".",
"next",
"return",
"dic",
".",
"get",
"(",
"head",
")"
] |
:type head: RandomListNode
:rtype: RandomListNode
|
[
":",
"type",
"head",
":",
"RandomListNode",
":",
"rtype",
":",
"RandomListNode"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/linkedlist/copy_random_pointer.py#L17-L31
|
train
|
keon/algorithms
|
algorithms/linkedlist/copy_random_pointer.py
|
copy_random_pointer_v2
|
def copy_random_pointer_v2(head):
"""
:type head: RandomListNode
:rtype: RandomListNode
"""
copy = defaultdict(lambda: RandomListNode(0))
copy[None] = None
node = head
while node:
copy[node].label = node.label
copy[node].next = copy[node.next]
copy[node].random = copy[node.random]
node = node.next
return copy[head]
|
python
|
def copy_random_pointer_v2(head):
"""
:type head: RandomListNode
:rtype: RandomListNode
"""
copy = defaultdict(lambda: RandomListNode(0))
copy[None] = None
node = head
while node:
copy[node].label = node.label
copy[node].next = copy[node.next]
copy[node].random = copy[node.random]
node = node.next
return copy[head]
|
[
"def",
"copy_random_pointer_v2",
"(",
"head",
")",
":",
"copy",
"=",
"defaultdict",
"(",
"lambda",
":",
"RandomListNode",
"(",
"0",
")",
")",
"copy",
"[",
"None",
"]",
"=",
"None",
"node",
"=",
"head",
"while",
"node",
":",
"copy",
"[",
"node",
"]",
".",
"label",
"=",
"node",
".",
"label",
"copy",
"[",
"node",
"]",
".",
"next",
"=",
"copy",
"[",
"node",
".",
"next",
"]",
"copy",
"[",
"node",
"]",
".",
"random",
"=",
"copy",
"[",
"node",
".",
"random",
"]",
"node",
"=",
"node",
".",
"next",
"return",
"copy",
"[",
"head",
"]"
] |
:type head: RandomListNode
:rtype: RandomListNode
|
[
":",
"type",
"head",
":",
"RandomListNode",
":",
"rtype",
":",
"RandomListNode"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/linkedlist/copy_random_pointer.py#L35-L48
|
train
|
keon/algorithms
|
algorithms/dfs/all_factors.py
|
get_factors
|
def get_factors(n):
"""[summary]
Arguments:
n {[int]} -- [to analysed number]
Returns:
[list of lists] -- [all factors of the number n]
"""
def factor(n, i, combi, res):
"""[summary]
helper function
Arguments:
n {[int]} -- [number]
i {[int]} -- [to tested divisor]
combi {[list]} -- [catch divisors]
res {[list]} -- [all factors of the number n]
Returns:
[list] -- [res]
"""
while i * i <= n:
if n % i == 0:
res += combi + [i, int(n/i)],
factor(n/i, i, combi+[i], res)
i += 1
return res
return factor(n, 2, [], [])
|
python
|
def get_factors(n):
"""[summary]
Arguments:
n {[int]} -- [to analysed number]
Returns:
[list of lists] -- [all factors of the number n]
"""
def factor(n, i, combi, res):
"""[summary]
helper function
Arguments:
n {[int]} -- [number]
i {[int]} -- [to tested divisor]
combi {[list]} -- [catch divisors]
res {[list]} -- [all factors of the number n]
Returns:
[list] -- [res]
"""
while i * i <= n:
if n % i == 0:
res += combi + [i, int(n/i)],
factor(n/i, i, combi+[i], res)
i += 1
return res
return factor(n, 2, [], [])
|
[
"def",
"get_factors",
"(",
"n",
")",
":",
"def",
"factor",
"(",
"n",
",",
"i",
",",
"combi",
",",
"res",
")",
":",
"\"\"\"[summary]\n helper function\n\n Arguments:\n n {[int]} -- [number]\n i {[int]} -- [to tested divisor]\n combi {[list]} -- [catch divisors]\n res {[list]} -- [all factors of the number n]\n \n Returns:\n [list] -- [res]\n \"\"\"",
"while",
"i",
"*",
"i",
"<=",
"n",
":",
"if",
"n",
"%",
"i",
"==",
"0",
":",
"res",
"+=",
"combi",
"+",
"[",
"i",
",",
"int",
"(",
"n",
"/",
"i",
")",
"]",
",",
"factor",
"(",
"n",
"/",
"i",
",",
"i",
",",
"combi",
"+",
"[",
"i",
"]",
",",
"res",
")",
"i",
"+=",
"1",
"return",
"res",
"return",
"factor",
"(",
"n",
",",
"2",
",",
"[",
"]",
",",
"[",
"]",
")"
] |
[summary]
Arguments:
n {[int]} -- [to analysed number]
Returns:
[list of lists] -- [all factors of the number n]
|
[
"[",
"summary",
"]",
"Arguments",
":",
"n",
"{",
"[",
"int",
"]",
"}",
"--",
"[",
"to",
"analysed",
"number",
"]",
"Returns",
":",
"[",
"list",
"of",
"lists",
"]",
"--",
"[",
"all",
"factors",
"of",
"the",
"number",
"n",
"]"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/dfs/all_factors.py#L30-L60
|
train
|
keon/algorithms
|
algorithms/dfs/all_factors.py
|
get_factors_iterative1
|
def get_factors_iterative1(n):
"""[summary]
Computes all factors of n.
Translated the function get_factors(...) in
a call-stack modell.
Arguments:
n {[int]} -- [to analysed number]
Returns:
[list of lists] -- [all factors]
"""
todo, res = [(n, 2, [])], []
while todo:
n, i, combi = todo.pop()
while i * i <= n:
if n % i == 0:
res += combi + [i, n//i],
todo.append((n//i, i, combi+[i])),
i += 1
return res
|
python
|
def get_factors_iterative1(n):
"""[summary]
Computes all factors of n.
Translated the function get_factors(...) in
a call-stack modell.
Arguments:
n {[int]} -- [to analysed number]
Returns:
[list of lists] -- [all factors]
"""
todo, res = [(n, 2, [])], []
while todo:
n, i, combi = todo.pop()
while i * i <= n:
if n % i == 0:
res += combi + [i, n//i],
todo.append((n//i, i, combi+[i])),
i += 1
return res
|
[
"def",
"get_factors_iterative1",
"(",
"n",
")",
":",
"todo",
",",
"res",
"=",
"[",
"(",
"n",
",",
"2",
",",
"[",
"]",
")",
"]",
",",
"[",
"]",
"while",
"todo",
":",
"n",
",",
"i",
",",
"combi",
"=",
"todo",
".",
"pop",
"(",
")",
"while",
"i",
"*",
"i",
"<=",
"n",
":",
"if",
"n",
"%",
"i",
"==",
"0",
":",
"res",
"+=",
"combi",
"+",
"[",
"i",
",",
"n",
"//",
"i",
"]",
",",
"todo",
".",
"append",
"(",
"(",
"n",
"//",
"i",
",",
"i",
",",
"combi",
"+",
"[",
"i",
"]",
")",
")",
",",
"i",
"+=",
"1",
"return",
"res"
] |
[summary]
Computes all factors of n.
Translated the function get_factors(...) in
a call-stack modell.
Arguments:
n {[int]} -- [to analysed number]
Returns:
[list of lists] -- [all factors]
|
[
"[",
"summary",
"]",
"Computes",
"all",
"factors",
"of",
"n",
".",
"Translated",
"the",
"function",
"get_factors",
"(",
"...",
")",
"in",
"a",
"call",
"-",
"stack",
"modell",
"."
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/dfs/all_factors.py#L63-L84
|
train
|
keon/algorithms
|
algorithms/dfs/all_factors.py
|
get_factors_iterative2
|
def get_factors_iterative2(n):
"""[summary]
analog as above
Arguments:
n {[int]} -- [description]
Returns:
[list of lists] -- [all factors of n]
"""
ans, stack, x = [], [], 2
while True:
if x > n // x:
if not stack:
return ans
ans.append(stack + [n])
x = stack.pop()
n *= x
x += 1
elif n % x == 0:
stack.append(x)
n //= x
else:
x += 1
|
python
|
def get_factors_iterative2(n):
"""[summary]
analog as above
Arguments:
n {[int]} -- [description]
Returns:
[list of lists] -- [all factors of n]
"""
ans, stack, x = [], [], 2
while True:
if x > n // x:
if not stack:
return ans
ans.append(stack + [n])
x = stack.pop()
n *= x
x += 1
elif n % x == 0:
stack.append(x)
n //= x
else:
x += 1
|
[
"def",
"get_factors_iterative2",
"(",
"n",
")",
":",
"ans",
",",
"stack",
",",
"x",
"=",
"[",
"]",
",",
"[",
"]",
",",
"2",
"while",
"True",
":",
"if",
"x",
">",
"n",
"//",
"x",
":",
"if",
"not",
"stack",
":",
"return",
"ans",
"ans",
".",
"append",
"(",
"stack",
"+",
"[",
"n",
"]",
")",
"x",
"=",
"stack",
".",
"pop",
"(",
")",
"n",
"*=",
"x",
"x",
"+=",
"1",
"elif",
"n",
"%",
"x",
"==",
"0",
":",
"stack",
".",
"append",
"(",
"x",
")",
"n",
"//=",
"x",
"else",
":",
"x",
"+=",
"1"
] |
[summary]
analog as above
Arguments:
n {[int]} -- [description]
Returns:
[list of lists] -- [all factors of n]
|
[
"[",
"summary",
"]",
"analog",
"as",
"above"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/dfs/all_factors.py#L87-L111
|
train
|
keon/algorithms
|
algorithms/dp/longest_increasing.py
|
longest_increasing_subsequence
|
def longest_increasing_subsequence(sequence):
"""
Dynamic Programming Algorithm for
counting the length of longest increasing subsequence
type sequence: List[int]
"""
length = len(sequence)
counts = [1 for _ in range(length)]
for i in range(1, length):
for j in range(0, i):
if sequence[i] > sequence[j]:
counts[i] = max(counts[i], counts[j] + 1)
print(counts)
return max(counts)
|
python
|
def longest_increasing_subsequence(sequence):
"""
Dynamic Programming Algorithm for
counting the length of longest increasing subsequence
type sequence: List[int]
"""
length = len(sequence)
counts = [1 for _ in range(length)]
for i in range(1, length):
for j in range(0, i):
if sequence[i] > sequence[j]:
counts[i] = max(counts[i], counts[j] + 1)
print(counts)
return max(counts)
|
[
"def",
"longest_increasing_subsequence",
"(",
"sequence",
")",
":",
"length",
"=",
"len",
"(",
"sequence",
")",
"counts",
"=",
"[",
"1",
"for",
"_",
"in",
"range",
"(",
"length",
")",
"]",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"length",
")",
":",
"for",
"j",
"in",
"range",
"(",
"0",
",",
"i",
")",
":",
"if",
"sequence",
"[",
"i",
"]",
">",
"sequence",
"[",
"j",
"]",
":",
"counts",
"[",
"i",
"]",
"=",
"max",
"(",
"counts",
"[",
"i",
"]",
",",
"counts",
"[",
"j",
"]",
"+",
"1",
")",
"print",
"(",
"counts",
")",
"return",
"max",
"(",
"counts",
")"
] |
Dynamic Programming Algorithm for
counting the length of longest increasing subsequence
type sequence: List[int]
|
[
"Dynamic",
"Programming",
"Algorithm",
"for",
"counting",
"the",
"length",
"of",
"longest",
"increasing",
"subsequence",
"type",
"sequence",
":",
"List",
"[",
"int",
"]"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/dp/longest_increasing.py#L13-L26
|
train
|
keon/algorithms
|
algorithms/bit/single_number3.py
|
single_number3
|
def single_number3(nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
# isolate a^b from pairs using XOR
ab = 0
for n in nums:
ab ^= n
# isolate right most bit from a^b
right_most = ab & (-ab)
# isolate a and b from a^b
a, b = 0, 0
for n in nums:
if n & right_most:
a ^= n
else:
b ^= n
return [a, b]
|
python
|
def single_number3(nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
# isolate a^b from pairs using XOR
ab = 0
for n in nums:
ab ^= n
# isolate right most bit from a^b
right_most = ab & (-ab)
# isolate a and b from a^b
a, b = 0, 0
for n in nums:
if n & right_most:
a ^= n
else:
b ^= n
return [a, b]
|
[
"def",
"single_number3",
"(",
"nums",
")",
":",
"# isolate a^b from pairs using XOR",
"ab",
"=",
"0",
"for",
"n",
"in",
"nums",
":",
"ab",
"^=",
"n",
"# isolate right most bit from a^b",
"right_most",
"=",
"ab",
"&",
"(",
"-",
"ab",
")",
"# isolate a and b from a^b",
"a",
",",
"b",
"=",
"0",
",",
"0",
"for",
"n",
"in",
"nums",
":",
"if",
"n",
"&",
"right_most",
":",
"a",
"^=",
"n",
"else",
":",
"b",
"^=",
"n",
"return",
"[",
"a",
",",
"b",
"]"
] |
:type nums: List[int]
:rtype: List[int]
|
[
":",
"type",
"nums",
":",
"List",
"[",
"int",
"]",
":",
"rtype",
":",
"List",
"[",
"int",
"]"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/bit/single_number3.py#L29-L49
|
train
|
keon/algorithms
|
algorithms/ml/nearest_neighbor.py
|
distance
|
def distance(x,y):
"""[summary]
HELPER-FUNCTION
calculates the (eulidean) distance between vector x and y.
Arguments:
x {[tuple]} -- [vector]
y {[tuple]} -- [vector]
"""
assert len(x) == len(y), "The vector must have same length"
result = ()
sum = 0
for i in range(len(x)):
result += (x[i] -y[i],)
for component in result:
sum += component**2
return math.sqrt(sum)
|
python
|
def distance(x,y):
"""[summary]
HELPER-FUNCTION
calculates the (eulidean) distance between vector x and y.
Arguments:
x {[tuple]} -- [vector]
y {[tuple]} -- [vector]
"""
assert len(x) == len(y), "The vector must have same length"
result = ()
sum = 0
for i in range(len(x)):
result += (x[i] -y[i],)
for component in result:
sum += component**2
return math.sqrt(sum)
|
[
"def",
"distance",
"(",
"x",
",",
"y",
")",
":",
"assert",
"len",
"(",
"x",
")",
"==",
"len",
"(",
"y",
")",
",",
"\"The vector must have same length\"",
"result",
"=",
"(",
")",
"sum",
"=",
"0",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"x",
")",
")",
":",
"result",
"+=",
"(",
"x",
"[",
"i",
"]",
"-",
"y",
"[",
"i",
"]",
",",
")",
"for",
"component",
"in",
"result",
":",
"sum",
"+=",
"component",
"**",
"2",
"return",
"math",
".",
"sqrt",
"(",
"sum",
")"
] |
[summary]
HELPER-FUNCTION
calculates the (eulidean) distance between vector x and y.
Arguments:
x {[tuple]} -- [vector]
y {[tuple]} -- [vector]
|
[
"[",
"summary",
"]",
"HELPER",
"-",
"FUNCTION",
"calculates",
"the",
"(",
"eulidean",
")",
"distance",
"between",
"vector",
"x",
"and",
"y",
"."
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/ml/nearest_neighbor.py#L3-L19
|
train
|
keon/algorithms
|
algorithms/ml/nearest_neighbor.py
|
nearest_neighbor
|
def nearest_neighbor(x, tSet):
"""[summary]
Implements the nearest neighbor algorithm
Arguments:
x {[tupel]} -- [vector]
tSet {[dict]} -- [training set]
Returns:
[type] -- [result of the AND-function]
"""
assert isinstance(x, tuple) and isinstance(tSet, dict)
current_key = ()
min_d = float('inf')
for key in tSet:
d = distance(x, key)
if d < min_d:
min_d = d
current_key = key
return tSet[current_key]
|
python
|
def nearest_neighbor(x, tSet):
"""[summary]
Implements the nearest neighbor algorithm
Arguments:
x {[tupel]} -- [vector]
tSet {[dict]} -- [training set]
Returns:
[type] -- [result of the AND-function]
"""
assert isinstance(x, tuple) and isinstance(tSet, dict)
current_key = ()
min_d = float('inf')
for key in tSet:
d = distance(x, key)
if d < min_d:
min_d = d
current_key = key
return tSet[current_key]
|
[
"def",
"nearest_neighbor",
"(",
"x",
",",
"tSet",
")",
":",
"assert",
"isinstance",
"(",
"x",
",",
"tuple",
")",
"and",
"isinstance",
"(",
"tSet",
",",
"dict",
")",
"current_key",
"=",
"(",
")",
"min_d",
"=",
"float",
"(",
"'inf'",
")",
"for",
"key",
"in",
"tSet",
":",
"d",
"=",
"distance",
"(",
"x",
",",
"key",
")",
"if",
"d",
"<",
"min_d",
":",
"min_d",
"=",
"d",
"current_key",
"=",
"key",
"return",
"tSet",
"[",
"current_key",
"]"
] |
[summary]
Implements the nearest neighbor algorithm
Arguments:
x {[tupel]} -- [vector]
tSet {[dict]} -- [training set]
Returns:
[type] -- [result of the AND-function]
|
[
"[",
"summary",
"]",
"Implements",
"the",
"nearest",
"neighbor",
"algorithm"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/ml/nearest_neighbor.py#L22-L41
|
train
|
keon/algorithms
|
algorithms/maths/is_strobogrammatic.py
|
is_strobogrammatic
|
def is_strobogrammatic(num):
"""
:type num: str
:rtype: bool
"""
comb = "00 11 88 69 96"
i = 0
j = len(num) - 1
while i <= j:
x = comb.find(num[i]+num[j])
if x == -1:
return False
i += 1
j -= 1
return True
|
python
|
def is_strobogrammatic(num):
"""
:type num: str
:rtype: bool
"""
comb = "00 11 88 69 96"
i = 0
j = len(num) - 1
while i <= j:
x = comb.find(num[i]+num[j])
if x == -1:
return False
i += 1
j -= 1
return True
|
[
"def",
"is_strobogrammatic",
"(",
"num",
")",
":",
"comb",
"=",
"\"00 11 88 69 96\"",
"i",
"=",
"0",
"j",
"=",
"len",
"(",
"num",
")",
"-",
"1",
"while",
"i",
"<=",
"j",
":",
"x",
"=",
"comb",
".",
"find",
"(",
"num",
"[",
"i",
"]",
"+",
"num",
"[",
"j",
"]",
")",
"if",
"x",
"==",
"-",
"1",
":",
"return",
"False",
"i",
"+=",
"1",
"j",
"-=",
"1",
"return",
"True"
] |
:type num: str
:rtype: bool
|
[
":",
"type",
"num",
":",
"str",
":",
"rtype",
":",
"bool"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/maths/is_strobogrammatic.py#L12-L26
|
train
|
keon/algorithms
|
algorithms/sort/merge_sort.py
|
merge_sort
|
def merge_sort(arr):
""" Merge Sort
Complexity: O(n log(n))
"""
# Our recursive base case
if len(arr) <= 1:
return arr
mid = len(arr) // 2
# Perform merge_sort recursively on both halves
left, right = merge_sort(arr[:mid]), merge_sort(arr[mid:])
# Merge each side together
return merge(left, right, arr.copy())
|
python
|
def merge_sort(arr):
""" Merge Sort
Complexity: O(n log(n))
"""
# Our recursive base case
if len(arr) <= 1:
return arr
mid = len(arr) // 2
# Perform merge_sort recursively on both halves
left, right = merge_sort(arr[:mid]), merge_sort(arr[mid:])
# Merge each side together
return merge(left, right, arr.copy())
|
[
"def",
"merge_sort",
"(",
"arr",
")",
":",
"# Our recursive base case",
"if",
"len",
"(",
"arr",
")",
"<=",
"1",
":",
"return",
"arr",
"mid",
"=",
"len",
"(",
"arr",
")",
"//",
"2",
"# Perform merge_sort recursively on both halves",
"left",
",",
"right",
"=",
"merge_sort",
"(",
"arr",
"[",
":",
"mid",
"]",
")",
",",
"merge_sort",
"(",
"arr",
"[",
"mid",
":",
"]",
")",
"# Merge each side together",
"return",
"merge",
"(",
"left",
",",
"right",
",",
"arr",
".",
"copy",
"(",
")",
")"
] |
Merge Sort
Complexity: O(n log(n))
|
[
"Merge",
"Sort",
"Complexity",
":",
"O",
"(",
"n",
"log",
"(",
"n",
"))"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/sort/merge_sort.py#L1-L13
|
train
|
keon/algorithms
|
algorithms/sort/merge_sort.py
|
merge
|
def merge(left, right, merged):
""" Merge helper
Complexity: O(n)
"""
left_cursor, right_cursor = 0, 0
while left_cursor < len(left) and right_cursor < len(right):
# Sort each one and place into the result
if left[left_cursor] <= right[right_cursor]:
merged[left_cursor+right_cursor]=left[left_cursor]
left_cursor += 1
else:
merged[left_cursor + right_cursor] = right[right_cursor]
right_cursor += 1
# Add the left overs if there's any left to the result
for left_cursor in range(left_cursor, len(left)):
merged[left_cursor + right_cursor] = left[left_cursor]
# Add the left overs if there's any left to the result
for right_cursor in range(right_cursor, len(right)):
merged[left_cursor + right_cursor] = right[right_cursor]
# Return result
return merged
|
python
|
def merge(left, right, merged):
""" Merge helper
Complexity: O(n)
"""
left_cursor, right_cursor = 0, 0
while left_cursor < len(left) and right_cursor < len(right):
# Sort each one and place into the result
if left[left_cursor] <= right[right_cursor]:
merged[left_cursor+right_cursor]=left[left_cursor]
left_cursor += 1
else:
merged[left_cursor + right_cursor] = right[right_cursor]
right_cursor += 1
# Add the left overs if there's any left to the result
for left_cursor in range(left_cursor, len(left)):
merged[left_cursor + right_cursor] = left[left_cursor]
# Add the left overs if there's any left to the result
for right_cursor in range(right_cursor, len(right)):
merged[left_cursor + right_cursor] = right[right_cursor]
# Return result
return merged
|
[
"def",
"merge",
"(",
"left",
",",
"right",
",",
"merged",
")",
":",
"left_cursor",
",",
"right_cursor",
"=",
"0",
",",
"0",
"while",
"left_cursor",
"<",
"len",
"(",
"left",
")",
"and",
"right_cursor",
"<",
"len",
"(",
"right",
")",
":",
"# Sort each one and place into the result",
"if",
"left",
"[",
"left_cursor",
"]",
"<=",
"right",
"[",
"right_cursor",
"]",
":",
"merged",
"[",
"left_cursor",
"+",
"right_cursor",
"]",
"=",
"left",
"[",
"left_cursor",
"]",
"left_cursor",
"+=",
"1",
"else",
":",
"merged",
"[",
"left_cursor",
"+",
"right_cursor",
"]",
"=",
"right",
"[",
"right_cursor",
"]",
"right_cursor",
"+=",
"1",
"# Add the left overs if there's any left to the result",
"for",
"left_cursor",
"in",
"range",
"(",
"left_cursor",
",",
"len",
"(",
"left",
")",
")",
":",
"merged",
"[",
"left_cursor",
"+",
"right_cursor",
"]",
"=",
"left",
"[",
"left_cursor",
"]",
"# Add the left overs if there's any left to the result",
"for",
"right_cursor",
"in",
"range",
"(",
"right_cursor",
",",
"len",
"(",
"right",
")",
")",
":",
"merged",
"[",
"left_cursor",
"+",
"right_cursor",
"]",
"=",
"right",
"[",
"right_cursor",
"]",
"# Return result",
"return",
"merged"
] |
Merge helper
Complexity: O(n)
|
[
"Merge",
"helper",
"Complexity",
":",
"O",
"(",
"n",
")"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/sort/merge_sort.py#L16-L38
|
train
|
keon/algorithms
|
algorithms/sort/bucket_sort.py
|
bucket_sort
|
def bucket_sort(arr):
''' Bucket Sort
Complexity: O(n^2)
The complexity is dominated by nextSort
'''
# The number of buckets and make buckets
num_buckets = len(arr)
buckets = [[] for bucket in range(num_buckets)]
# Assign values into bucket_sort
for value in arr:
index = value * num_buckets // (max(arr) + 1)
buckets[index].append(value)
# Sort
sorted_list = []
for i in range(num_buckets):
sorted_list.extend(next_sort(buckets[i]))
return sorted_list
|
python
|
def bucket_sort(arr):
''' Bucket Sort
Complexity: O(n^2)
The complexity is dominated by nextSort
'''
# The number of buckets and make buckets
num_buckets = len(arr)
buckets = [[] for bucket in range(num_buckets)]
# Assign values into bucket_sort
for value in arr:
index = value * num_buckets // (max(arr) + 1)
buckets[index].append(value)
# Sort
sorted_list = []
for i in range(num_buckets):
sorted_list.extend(next_sort(buckets[i]))
return sorted_list
|
[
"def",
"bucket_sort",
"(",
"arr",
")",
":",
"# The number of buckets and make buckets",
"num_buckets",
"=",
"len",
"(",
"arr",
")",
"buckets",
"=",
"[",
"[",
"]",
"for",
"bucket",
"in",
"range",
"(",
"num_buckets",
")",
"]",
"# Assign values into bucket_sort",
"for",
"value",
"in",
"arr",
":",
"index",
"=",
"value",
"*",
"num_buckets",
"//",
"(",
"max",
"(",
"arr",
")",
"+",
"1",
")",
"buckets",
"[",
"index",
"]",
".",
"append",
"(",
"value",
")",
"# Sort",
"sorted_list",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"num_buckets",
")",
":",
"sorted_list",
".",
"extend",
"(",
"next_sort",
"(",
"buckets",
"[",
"i",
"]",
")",
")",
"return",
"sorted_list"
] |
Bucket Sort
Complexity: O(n^2)
The complexity is dominated by nextSort
|
[
"Bucket",
"Sort",
"Complexity",
":",
"O",
"(",
"n^2",
")",
"The",
"complexity",
"is",
"dominated",
"by",
"nextSort"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/sort/bucket_sort.py#L1-L17
|
train
|
keon/algorithms
|
algorithms/heap/k_closest_points.py
|
k_closest
|
def k_closest(points, k, origin=(0, 0)):
# Time: O(k+(n-k)logk)
# Space: O(k)
"""Initialize max heap with first k points.
Python does not support a max heap; thus we can use the default min heap where the keys (distance) are negated.
"""
heap = [(-distance(p, origin), p) for p in points[:k]]
heapify(heap)
"""
For every point p in points[k:],
check if p is smaller than the root of the max heap;
if it is, add p to heap and remove root. Reheapify.
"""
for p in points[k:]:
d = distance(p, origin)
heappushpop(heap, (-d, p)) # heappushpop does conditional check
"""Same as:
if d < -heap[0][0]:
heappush(heap, (-d,p))
heappop(heap)
Note: heappushpop is more efficient than separate push and pop calls.
Each heappushpop call takes O(logk) time.
"""
return [p for nd, p in heap]
|
python
|
def k_closest(points, k, origin=(0, 0)):
# Time: O(k+(n-k)logk)
# Space: O(k)
"""Initialize max heap with first k points.
Python does not support a max heap; thus we can use the default min heap where the keys (distance) are negated.
"""
heap = [(-distance(p, origin), p) for p in points[:k]]
heapify(heap)
"""
For every point p in points[k:],
check if p is smaller than the root of the max heap;
if it is, add p to heap and remove root. Reheapify.
"""
for p in points[k:]:
d = distance(p, origin)
heappushpop(heap, (-d, p)) # heappushpop does conditional check
"""Same as:
if d < -heap[0][0]:
heappush(heap, (-d,p))
heappop(heap)
Note: heappushpop is more efficient than separate push and pop calls.
Each heappushpop call takes O(logk) time.
"""
return [p for nd, p in heap]
|
[
"def",
"k_closest",
"(",
"points",
",",
"k",
",",
"origin",
"=",
"(",
"0",
",",
"0",
")",
")",
":",
"# Time: O(k+(n-k)logk)",
"# Space: O(k)",
"heap",
"=",
"[",
"(",
"-",
"distance",
"(",
"p",
",",
"origin",
")",
",",
"p",
")",
"for",
"p",
"in",
"points",
"[",
":",
"k",
"]",
"]",
"heapify",
"(",
"heap",
")",
"\"\"\"\n For every point p in points[k:],\n check if p is smaller than the root of the max heap;\n if it is, add p to heap and remove root. Reheapify.\n \"\"\"",
"for",
"p",
"in",
"points",
"[",
"k",
":",
"]",
":",
"d",
"=",
"distance",
"(",
"p",
",",
"origin",
")",
"heappushpop",
"(",
"heap",
",",
"(",
"-",
"d",
",",
"p",
")",
")",
"# heappushpop does conditional check",
"\"\"\"Same as:\n if d < -heap[0][0]:\n heappush(heap, (-d,p))\n heappop(heap)\n\n Note: heappushpop is more efficient than separate push and pop calls.\n Each heappushpop call takes O(logk) time.\n \"\"\"",
"return",
"[",
"p",
"for",
"nd",
",",
"p",
"in",
"heap",
"]"
] |
Initialize max heap with first k points.
Python does not support a max heap; thus we can use the default min heap where the keys (distance) are negated.
|
[
"Initialize",
"max",
"heap",
"with",
"first",
"k",
"points",
".",
"Python",
"does",
"not",
"support",
"a",
"max",
"heap",
";",
"thus",
"we",
"can",
"use",
"the",
"default",
"min",
"heap",
"where",
"the",
"keys",
"(",
"distance",
")",
"are",
"negated",
"."
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/heap/k_closest_points.py#L13-L40
|
train
|
keon/algorithms
|
algorithms/linkedlist/reverse.py
|
reverse_list
|
def reverse_list(head):
"""
:type head: ListNode
:rtype: ListNode
"""
if not head or not head.next:
return head
prev = None
while head:
current = head
head = head.next
current.next = prev
prev = current
return prev
|
python
|
def reverse_list(head):
"""
:type head: ListNode
:rtype: ListNode
"""
if not head or not head.next:
return head
prev = None
while head:
current = head
head = head.next
current.next = prev
prev = current
return prev
|
[
"def",
"reverse_list",
"(",
"head",
")",
":",
"if",
"not",
"head",
"or",
"not",
"head",
".",
"next",
":",
"return",
"head",
"prev",
"=",
"None",
"while",
"head",
":",
"current",
"=",
"head",
"head",
"=",
"head",
".",
"next",
"current",
".",
"next",
"=",
"prev",
"prev",
"=",
"current",
"return",
"prev"
] |
:type head: ListNode
:rtype: ListNode
|
[
":",
"type",
"head",
":",
"ListNode",
":",
"rtype",
":",
"ListNode"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/linkedlist/reverse.py#L12-L25
|
train
|
keon/algorithms
|
algorithms/linkedlist/reverse.py
|
reverse_list_recursive
|
def reverse_list_recursive(head):
"""
:type head: ListNode
:rtype: ListNode
"""
if head is None or head.next is None:
return head
p = head.next
head.next = None
revrest = reverse_list_recursive(p)
p.next = head
return revrest
|
python
|
def reverse_list_recursive(head):
"""
:type head: ListNode
:rtype: ListNode
"""
if head is None or head.next is None:
return head
p = head.next
head.next = None
revrest = reverse_list_recursive(p)
p.next = head
return revrest
|
[
"def",
"reverse_list_recursive",
"(",
"head",
")",
":",
"if",
"head",
"is",
"None",
"or",
"head",
".",
"next",
"is",
"None",
":",
"return",
"head",
"p",
"=",
"head",
".",
"next",
"head",
".",
"next",
"=",
"None",
"revrest",
"=",
"reverse_list_recursive",
"(",
"p",
")",
"p",
".",
"next",
"=",
"head",
"return",
"revrest"
] |
:type head: ListNode
:rtype: ListNode
|
[
":",
"type",
"head",
":",
"ListNode",
":",
"rtype",
":",
"ListNode"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/linkedlist/reverse.py#L32-L43
|
train
|
keon/algorithms
|
algorithms/tree/path_sum.py
|
has_path_sum
|
def has_path_sum(root, sum):
"""
:type root: TreeNode
:type sum: int
:rtype: bool
"""
if root is None:
return False
if root.left is None and root.right is None and root.val == sum:
return True
sum -= root.val
return has_path_sum(root.left, sum) or has_path_sum(root.right, sum)
|
python
|
def has_path_sum(root, sum):
"""
:type root: TreeNode
:type sum: int
:rtype: bool
"""
if root is None:
return False
if root.left is None and root.right is None and root.val == sum:
return True
sum -= root.val
return has_path_sum(root.left, sum) or has_path_sum(root.right, sum)
|
[
"def",
"has_path_sum",
"(",
"root",
",",
"sum",
")",
":",
"if",
"root",
"is",
"None",
":",
"return",
"False",
"if",
"root",
".",
"left",
"is",
"None",
"and",
"root",
".",
"right",
"is",
"None",
"and",
"root",
".",
"val",
"==",
"sum",
":",
"return",
"True",
"sum",
"-=",
"root",
".",
"val",
"return",
"has_path_sum",
"(",
"root",
".",
"left",
",",
"sum",
")",
"or",
"has_path_sum",
"(",
"root",
".",
"right",
",",
"sum",
")"
] |
:type root: TreeNode
:type sum: int
:rtype: bool
|
[
":",
"type",
"root",
":",
"TreeNode",
":",
"type",
"sum",
":",
"int",
":",
"rtype",
":",
"bool"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/tree/path_sum.py#L18-L29
|
train
|
keon/algorithms
|
algorithms/maths/base_conversion.py
|
int_to_base
|
def int_to_base(n, base):
"""
:type n: int
:type base: int
:rtype: str
"""
is_negative = False
if n == 0:
return '0'
elif n < 0:
is_negative = True
n *= -1
digit = string.digits + string.ascii_uppercase
res = ''
while n > 0:
res += digit[n % base]
n //= base
if is_negative:
return '-' + res[::-1]
else:
return res[::-1]
|
python
|
def int_to_base(n, base):
"""
:type n: int
:type base: int
:rtype: str
"""
is_negative = False
if n == 0:
return '0'
elif n < 0:
is_negative = True
n *= -1
digit = string.digits + string.ascii_uppercase
res = ''
while n > 0:
res += digit[n % base]
n //= base
if is_negative:
return '-' + res[::-1]
else:
return res[::-1]
|
[
"def",
"int_to_base",
"(",
"n",
",",
"base",
")",
":",
"is_negative",
"=",
"False",
"if",
"n",
"==",
"0",
":",
"return",
"'0'",
"elif",
"n",
"<",
"0",
":",
"is_negative",
"=",
"True",
"n",
"*=",
"-",
"1",
"digit",
"=",
"string",
".",
"digits",
"+",
"string",
".",
"ascii_uppercase",
"res",
"=",
"''",
"while",
"n",
">",
"0",
":",
"res",
"+=",
"digit",
"[",
"n",
"%",
"base",
"]",
"n",
"//=",
"base",
"if",
"is_negative",
":",
"return",
"'-'",
"+",
"res",
"[",
":",
":",
"-",
"1",
"]",
"else",
":",
"return",
"res",
"[",
":",
":",
"-",
"1",
"]"
] |
:type n: int
:type base: int
:rtype: str
|
[
":",
"type",
"n",
":",
"int",
":",
"type",
"base",
":",
"int",
":",
"rtype",
":",
"str"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/maths/base_conversion.py#L11-L31
|
train
|
keon/algorithms
|
algorithms/maths/base_conversion.py
|
base_to_int
|
def base_to_int(s, base):
"""
Note : You can use int() built-in function instread of this.
:type s: str
:type base: int
:rtype: int
"""
digit = {}
for i,c in enumerate(string.digits + string.ascii_uppercase):
digit[c] = i
multiplier = 1
res = 0
for c in s[::-1]:
res += digit[c] * multiplier
multiplier *= base
return res
|
python
|
def base_to_int(s, base):
"""
Note : You can use int() built-in function instread of this.
:type s: str
:type base: int
:rtype: int
"""
digit = {}
for i,c in enumerate(string.digits + string.ascii_uppercase):
digit[c] = i
multiplier = 1
res = 0
for c in s[::-1]:
res += digit[c] * multiplier
multiplier *= base
return res
|
[
"def",
"base_to_int",
"(",
"s",
",",
"base",
")",
":",
"digit",
"=",
"{",
"}",
"for",
"i",
",",
"c",
"in",
"enumerate",
"(",
"string",
".",
"digits",
"+",
"string",
".",
"ascii_uppercase",
")",
":",
"digit",
"[",
"c",
"]",
"=",
"i",
"multiplier",
"=",
"1",
"res",
"=",
"0",
"for",
"c",
"in",
"s",
"[",
":",
":",
"-",
"1",
"]",
":",
"res",
"+=",
"digit",
"[",
"c",
"]",
"*",
"multiplier",
"multiplier",
"*=",
"base",
"return",
"res"
] |
Note : You can use int() built-in function instread of this.
:type s: str
:type base: int
:rtype: int
|
[
"Note",
":",
"You",
"can",
"use",
"int",
"()",
"built",
"-",
"in",
"function",
"instread",
"of",
"this",
".",
":",
"type",
"s",
":",
"str",
":",
"type",
"base",
":",
"int",
":",
"rtype",
":",
"int"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/maths/base_conversion.py#L34-L50
|
train
|
keon/algorithms
|
algorithms/linkedlist/is_cyclic.py
|
is_cyclic
|
def is_cyclic(head):
"""
:type head: Node
:rtype: bool
"""
if not head:
return False
runner = head
walker = head
while runner.next and runner.next.next:
runner = runner.next.next
walker = walker.next
if runner == walker:
return True
return False
|
python
|
def is_cyclic(head):
"""
:type head: Node
:rtype: bool
"""
if not head:
return False
runner = head
walker = head
while runner.next and runner.next.next:
runner = runner.next.next
walker = walker.next
if runner == walker:
return True
return False
|
[
"def",
"is_cyclic",
"(",
"head",
")",
":",
"if",
"not",
"head",
":",
"return",
"False",
"runner",
"=",
"head",
"walker",
"=",
"head",
"while",
"runner",
".",
"next",
"and",
"runner",
".",
"next",
".",
"next",
":",
"runner",
"=",
"runner",
".",
"next",
".",
"next",
"walker",
"=",
"walker",
".",
"next",
"if",
"runner",
"==",
"walker",
":",
"return",
"True",
"return",
"False"
] |
:type head: Node
:rtype: bool
|
[
":",
"type",
"head",
":",
"Node",
":",
"rtype",
":",
"bool"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/linkedlist/is_cyclic.py#L13-L27
|
train
|
keon/algorithms
|
algorithms/strings/decode_string.py
|
decode_string
|
def decode_string(s):
"""
:type s: str
:rtype: str
"""
stack = []; cur_num = 0; cur_string = ''
for c in s:
if c == '[':
stack.append((cur_string, cur_num))
cur_string = ''
cur_num = 0
elif c == ']':
prev_string, num = stack.pop()
cur_string = prev_string + num * cur_string
elif c.isdigit():
cur_num = cur_num*10 + int(c)
else:
cur_string += c
return cur_string
|
python
|
def decode_string(s):
"""
:type s: str
:rtype: str
"""
stack = []; cur_num = 0; cur_string = ''
for c in s:
if c == '[':
stack.append((cur_string, cur_num))
cur_string = ''
cur_num = 0
elif c == ']':
prev_string, num = stack.pop()
cur_string = prev_string + num * cur_string
elif c.isdigit():
cur_num = cur_num*10 + int(c)
else:
cur_string += c
return cur_string
|
[
"def",
"decode_string",
"(",
"s",
")",
":",
"stack",
"=",
"[",
"]",
"cur_num",
"=",
"0",
"cur_string",
"=",
"''",
"for",
"c",
"in",
"s",
":",
"if",
"c",
"==",
"'['",
":",
"stack",
".",
"append",
"(",
"(",
"cur_string",
",",
"cur_num",
")",
")",
"cur_string",
"=",
"''",
"cur_num",
"=",
"0",
"elif",
"c",
"==",
"']'",
":",
"prev_string",
",",
"num",
"=",
"stack",
".",
"pop",
"(",
")",
"cur_string",
"=",
"prev_string",
"+",
"num",
"*",
"cur_string",
"elif",
"c",
".",
"isdigit",
"(",
")",
":",
"cur_num",
"=",
"cur_num",
"*",
"10",
"+",
"int",
"(",
"c",
")",
"else",
":",
"cur_string",
"+=",
"c",
"return",
"cur_string"
] |
:type s: str
:rtype: str
|
[
":",
"type",
"s",
":",
"str",
":",
"rtype",
":",
"str"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/strings/decode_string.py#L20-L38
|
train
|
keon/algorithms
|
algorithms/backtrack/palindrome_partitioning.py
|
palindromic_substrings_iter
|
def palindromic_substrings_iter(s):
"""
A slightly more Pythonic approach with a recursive generator
"""
if not s:
yield []
return
for i in range(len(s), 0, -1):
sub = s[:i]
if sub == sub[::-1]:
for rest in palindromic_substrings_iter(s[i:]):
yield [sub] + rest
|
python
|
def palindromic_substrings_iter(s):
"""
A slightly more Pythonic approach with a recursive generator
"""
if not s:
yield []
return
for i in range(len(s), 0, -1):
sub = s[:i]
if sub == sub[::-1]:
for rest in palindromic_substrings_iter(s[i:]):
yield [sub] + rest
|
[
"def",
"palindromic_substrings_iter",
"(",
"s",
")",
":",
"if",
"not",
"s",
":",
"yield",
"[",
"]",
"return",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"s",
")",
",",
"0",
",",
"-",
"1",
")",
":",
"sub",
"=",
"s",
"[",
":",
"i",
"]",
"if",
"sub",
"==",
"sub",
"[",
":",
":",
"-",
"1",
"]",
":",
"for",
"rest",
"in",
"palindromic_substrings_iter",
"(",
"s",
"[",
"i",
":",
"]",
")",
":",
"yield",
"[",
"sub",
"]",
"+",
"rest"
] |
A slightly more Pythonic approach with a recursive generator
|
[
"A",
"slightly",
"more",
"Pythonic",
"approach",
"with",
"a",
"recursive",
"generator"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/backtrack/palindrome_partitioning.py#L34-L45
|
train
|
keon/algorithms
|
algorithms/map/is_isomorphic.py
|
is_isomorphic
|
def is_isomorphic(s, t):
"""
:type s: str
:type t: str
:rtype: bool
"""
if len(s) != len(t):
return False
dict = {}
set_value = set()
for i in range(len(s)):
if s[i] not in dict:
if t[i] in set_value:
return False
dict[s[i]] = t[i]
set_value.add(t[i])
else:
if dict[s[i]] != t[i]:
return False
return True
|
python
|
def is_isomorphic(s, t):
"""
:type s: str
:type t: str
:rtype: bool
"""
if len(s) != len(t):
return False
dict = {}
set_value = set()
for i in range(len(s)):
if s[i] not in dict:
if t[i] in set_value:
return False
dict[s[i]] = t[i]
set_value.add(t[i])
else:
if dict[s[i]] != t[i]:
return False
return True
|
[
"def",
"is_isomorphic",
"(",
"s",
",",
"t",
")",
":",
"if",
"len",
"(",
"s",
")",
"!=",
"len",
"(",
"t",
")",
":",
"return",
"False",
"dict",
"=",
"{",
"}",
"set_value",
"=",
"set",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"s",
")",
")",
":",
"if",
"s",
"[",
"i",
"]",
"not",
"in",
"dict",
":",
"if",
"t",
"[",
"i",
"]",
"in",
"set_value",
":",
"return",
"False",
"dict",
"[",
"s",
"[",
"i",
"]",
"]",
"=",
"t",
"[",
"i",
"]",
"set_value",
".",
"add",
"(",
"t",
"[",
"i",
"]",
")",
"else",
":",
"if",
"dict",
"[",
"s",
"[",
"i",
"]",
"]",
"!=",
"t",
"[",
"i",
"]",
":",
"return",
"False",
"return",
"True"
] |
:type s: str
:type t: str
:rtype: bool
|
[
":",
"type",
"s",
":",
"str",
":",
"type",
"t",
":",
"str",
":",
"rtype",
":",
"bool"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/map/is_isomorphic.py#L21-L40
|
train
|
keon/algorithms
|
algorithms/calculator/math_parser.py
|
calc
|
def calc(n2, n1, operator):
"""
Calculate operation result
n2 Number: Number 2
n1 Number: Number 1
operator Char: Operation to calculate
"""
if operator == '-': return n1 - n2
elif operator == '+': return n1 + n2
elif operator == '*': return n1 * n2
elif operator == '/': return n1 / n2
elif operator == '^': return n1 ** n2
return 0
|
python
|
def calc(n2, n1, operator):
"""
Calculate operation result
n2 Number: Number 2
n1 Number: Number 1
operator Char: Operation to calculate
"""
if operator == '-': return n1 - n2
elif operator == '+': return n1 + n2
elif operator == '*': return n1 * n2
elif operator == '/': return n1 / n2
elif operator == '^': return n1 ** n2
return 0
|
[
"def",
"calc",
"(",
"n2",
",",
"n1",
",",
"operator",
")",
":",
"if",
"operator",
"==",
"'-'",
":",
"return",
"n1",
"-",
"n2",
"elif",
"operator",
"==",
"'+'",
":",
"return",
"n1",
"+",
"n2",
"elif",
"operator",
"==",
"'*'",
":",
"return",
"n1",
"*",
"n2",
"elif",
"operator",
"==",
"'/'",
":",
"return",
"n1",
"/",
"n2",
"elif",
"operator",
"==",
"'^'",
":",
"return",
"n1",
"**",
"n2",
"return",
"0"
] |
Calculate operation result
n2 Number: Number 2
n1 Number: Number 1
operator Char: Operation to calculate
|
[
"Calculate",
"operation",
"result",
"n2",
"Number",
":",
"Number",
"2",
"n1",
"Number",
":",
"Number",
"1",
"operator",
"Char",
":",
"Operation",
"to",
"calculate"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/calculator/math_parser.py#L53-L66
|
train
|
keon/algorithms
|
algorithms/calculator/math_parser.py
|
apply_operation
|
def apply_operation(op_stack, out_stack):
"""
Apply operation to the first 2 items of the output queue
op_stack Deque (reference)
out_stack Deque (reference)
"""
out_stack.append(calc(out_stack.pop(), out_stack.pop(), op_stack.pop()))
|
python
|
def apply_operation(op_stack, out_stack):
"""
Apply operation to the first 2 items of the output queue
op_stack Deque (reference)
out_stack Deque (reference)
"""
out_stack.append(calc(out_stack.pop(), out_stack.pop(), op_stack.pop()))
|
[
"def",
"apply_operation",
"(",
"op_stack",
",",
"out_stack",
")",
":",
"out_stack",
".",
"append",
"(",
"calc",
"(",
"out_stack",
".",
"pop",
"(",
")",
",",
"out_stack",
".",
"pop",
"(",
")",
",",
"op_stack",
".",
"pop",
"(",
")",
")",
")"
] |
Apply operation to the first 2 items of the output queue
op_stack Deque (reference)
out_stack Deque (reference)
|
[
"Apply",
"operation",
"to",
"the",
"first",
"2",
"items",
"of",
"the",
"output",
"queue",
"op_stack",
"Deque",
"(",
"reference",
")",
"out_stack",
"Deque",
"(",
"reference",
")"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/calculator/math_parser.py#L68-L75
|
train
|
keon/algorithms
|
algorithms/calculator/math_parser.py
|
parse
|
def parse(expression):
"""
Return array of parsed tokens in the expression
expression String: Math expression to parse in infix notation
"""
result = []
current = ""
for i in expression:
if i.isdigit() or i == '.':
current += i
else:
if len(current) > 0:
result.append(current)
current = ""
if i in __operators__ or i in __parenthesis__:
result.append(i)
else:
raise Exception("invalid syntax " + i)
if len(current) > 0:
result.append(current)
return result
|
python
|
def parse(expression):
"""
Return array of parsed tokens in the expression
expression String: Math expression to parse in infix notation
"""
result = []
current = ""
for i in expression:
if i.isdigit() or i == '.':
current += i
else:
if len(current) > 0:
result.append(current)
current = ""
if i in __operators__ or i in __parenthesis__:
result.append(i)
else:
raise Exception("invalid syntax " + i)
if len(current) > 0:
result.append(current)
return result
|
[
"def",
"parse",
"(",
"expression",
")",
":",
"result",
"=",
"[",
"]",
"current",
"=",
"\"\"",
"for",
"i",
"in",
"expression",
":",
"if",
"i",
".",
"isdigit",
"(",
")",
"or",
"i",
"==",
"'.'",
":",
"current",
"+=",
"i",
"else",
":",
"if",
"len",
"(",
"current",
")",
">",
"0",
":",
"result",
".",
"append",
"(",
"current",
")",
"current",
"=",
"\"\"",
"if",
"i",
"in",
"__operators__",
"or",
"i",
"in",
"__parenthesis__",
":",
"result",
".",
"append",
"(",
"i",
")",
"else",
":",
"raise",
"Exception",
"(",
"\"invalid syntax \"",
"+",
"i",
")",
"if",
"len",
"(",
"current",
")",
">",
"0",
":",
"result",
".",
"append",
"(",
"current",
")",
"return",
"result"
] |
Return array of parsed tokens in the expression
expression String: Math expression to parse in infix notation
|
[
"Return",
"array",
"of",
"parsed",
"tokens",
"in",
"the",
"expression",
"expression",
"String",
":",
"Math",
"expression",
"to",
"parse",
"in",
"infix",
"notation"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/calculator/math_parser.py#L77-L99
|
train
|
keon/algorithms
|
algorithms/calculator/math_parser.py
|
evaluate
|
def evaluate(expression):
"""
Calculate result of expression
expression String: The expression
type Type (optional): Number type [int, float]
"""
op_stack = deque() # operator stack
out_stack = deque() # output stack (values)
tokens = parse(expression) # calls the function only once!
for token in tokens:
if numeric_value.match(token):
out_stack.append(float(token))
elif token == '(':
op_stack.append(token)
elif token == ')':
while len(op_stack) > 0 and op_stack[-1] != '(':
apply_operation(op_stack, out_stack)
op_stack.pop() # Remove remaining '('
else: # is_operator(token)
while len(op_stack) > 0 and is_operator(op_stack[-1]) and higher_priority(op_stack[-1], token):
apply_operation(op_stack, out_stack)
op_stack.append(token)
while len(op_stack) > 0:
apply_operation(op_stack, out_stack)
return out_stack[-1]
|
python
|
def evaluate(expression):
"""
Calculate result of expression
expression String: The expression
type Type (optional): Number type [int, float]
"""
op_stack = deque() # operator stack
out_stack = deque() # output stack (values)
tokens = parse(expression) # calls the function only once!
for token in tokens:
if numeric_value.match(token):
out_stack.append(float(token))
elif token == '(':
op_stack.append(token)
elif token == ')':
while len(op_stack) > 0 and op_stack[-1] != '(':
apply_operation(op_stack, out_stack)
op_stack.pop() # Remove remaining '('
else: # is_operator(token)
while len(op_stack) > 0 and is_operator(op_stack[-1]) and higher_priority(op_stack[-1], token):
apply_operation(op_stack, out_stack)
op_stack.append(token)
while len(op_stack) > 0:
apply_operation(op_stack, out_stack)
return out_stack[-1]
|
[
"def",
"evaluate",
"(",
"expression",
")",
":",
"op_stack",
"=",
"deque",
"(",
")",
"# operator stack\r",
"out_stack",
"=",
"deque",
"(",
")",
"# output stack (values)\r",
"tokens",
"=",
"parse",
"(",
"expression",
")",
"# calls the function only once!\r",
"for",
"token",
"in",
"tokens",
":",
"if",
"numeric_value",
".",
"match",
"(",
"token",
")",
":",
"out_stack",
".",
"append",
"(",
"float",
"(",
"token",
")",
")",
"elif",
"token",
"==",
"'('",
":",
"op_stack",
".",
"append",
"(",
"token",
")",
"elif",
"token",
"==",
"')'",
":",
"while",
"len",
"(",
"op_stack",
")",
">",
"0",
"and",
"op_stack",
"[",
"-",
"1",
"]",
"!=",
"'('",
":",
"apply_operation",
"(",
"op_stack",
",",
"out_stack",
")",
"op_stack",
".",
"pop",
"(",
")",
"# Remove remaining '('\r",
"else",
":",
"# is_operator(token)\r",
"while",
"len",
"(",
"op_stack",
")",
">",
"0",
"and",
"is_operator",
"(",
"op_stack",
"[",
"-",
"1",
"]",
")",
"and",
"higher_priority",
"(",
"op_stack",
"[",
"-",
"1",
"]",
",",
"token",
")",
":",
"apply_operation",
"(",
"op_stack",
",",
"out_stack",
")",
"op_stack",
".",
"append",
"(",
"token",
")",
"while",
"len",
"(",
"op_stack",
")",
">",
"0",
":",
"apply_operation",
"(",
"op_stack",
",",
"out_stack",
")",
"return",
"out_stack",
"[",
"-",
"1",
"]"
] |
Calculate result of expression
expression String: The expression
type Type (optional): Number type [int, float]
|
[
"Calculate",
"result",
"of",
"expression",
"expression",
"String",
":",
"The",
"expression",
"type",
"Type",
"(",
"optional",
")",
":",
"Number",
"type",
"[",
"int",
"float",
"]"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/calculator/math_parser.py#L101-L128
|
train
|
keon/algorithms
|
algorithms/calculator/math_parser.py
|
main
|
def main():
"""
simple user-interface
"""
print("\t\tCalculator\n\n")
while True:
user_input = input("expression or exit: ")
if user_input == "exit":
break
try:
print("The result is {0}".format(evaluate(user_input)))
except Exception:
print("invalid syntax!")
user_input = input("expression or exit: ")
print("program end")
|
python
|
def main():
"""
simple user-interface
"""
print("\t\tCalculator\n\n")
while True:
user_input = input("expression or exit: ")
if user_input == "exit":
break
try:
print("The result is {0}".format(evaluate(user_input)))
except Exception:
print("invalid syntax!")
user_input = input("expression or exit: ")
print("program end")
|
[
"def",
"main",
"(",
")",
":",
"print",
"(",
"\"\\t\\tCalculator\\n\\n\"",
")",
"while",
"True",
":",
"user_input",
"=",
"input",
"(",
"\"expression or exit: \"",
")",
"if",
"user_input",
"==",
"\"exit\"",
":",
"break",
"try",
":",
"print",
"(",
"\"The result is {0}\"",
".",
"format",
"(",
"evaluate",
"(",
"user_input",
")",
")",
")",
"except",
"Exception",
":",
"print",
"(",
"\"invalid syntax!\"",
")",
"user_input",
"=",
"input",
"(",
"\"expression or exit: \"",
")",
"print",
"(",
"\"program end\"",
")"
] |
simple user-interface
|
[
"simple",
"user",
"-",
"interface"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/calculator/math_parser.py#L131-L145
|
train
|
keon/algorithms
|
algorithms/tree/bst/bst_closest_value.py
|
closest_value
|
def closest_value(root, target):
"""
:type root: TreeNode
:type target: float
:rtype: int
"""
a = root.val
kid = root.left if target < a else root.right
if not kid:
return a
b = closest_value(kid, target)
return min((a,b), key=lambda x: abs(target-x))
|
python
|
def closest_value(root, target):
"""
:type root: TreeNode
:type target: float
:rtype: int
"""
a = root.val
kid = root.left if target < a else root.right
if not kid:
return a
b = closest_value(kid, target)
return min((a,b), key=lambda x: abs(target-x))
|
[
"def",
"closest_value",
"(",
"root",
",",
"target",
")",
":",
"a",
"=",
"root",
".",
"val",
"kid",
"=",
"root",
".",
"left",
"if",
"target",
"<",
"a",
"else",
"root",
".",
"right",
"if",
"not",
"kid",
":",
"return",
"a",
"b",
"=",
"closest_value",
"(",
"kid",
",",
"target",
")",
"return",
"min",
"(",
"(",
"a",
",",
"b",
")",
",",
"key",
"=",
"lambda",
"x",
":",
"abs",
"(",
"target",
"-",
"x",
")",
")"
] |
:type root: TreeNode
:type target: float
:rtype: int
|
[
":",
"type",
"root",
":",
"TreeNode",
":",
"type",
"target",
":",
"float",
":",
"rtype",
":",
"int"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/tree/bst/bst_closest_value.py#L17-L28
|
train
|
keon/algorithms
|
algorithms/maths/primes_sieve_of_eratosthenes.py
|
get_primes
|
def get_primes(n):
"""Return list of all primes less than n,
Using sieve of Eratosthenes.
"""
if n <= 0:
raise ValueError("'n' must be a positive integer.")
# If x is even, exclude x from list (-1):
sieve_size = (n // 2 - 1) if n % 2 == 0 else (n // 2)
sieve = [True for _ in range(sieve_size)] # Sieve
primes = [] # List of Primes
if n >= 2:
primes.append(2) # 2 is prime by default
for i in range(sieve_size):
if sieve[i]:
value_at_i = i*2 + 3
primes.append(value_at_i)
for j in range(i, sieve_size, value_at_i):
sieve[j] = False
return primes
|
python
|
def get_primes(n):
"""Return list of all primes less than n,
Using sieve of Eratosthenes.
"""
if n <= 0:
raise ValueError("'n' must be a positive integer.")
# If x is even, exclude x from list (-1):
sieve_size = (n // 2 - 1) if n % 2 == 0 else (n // 2)
sieve = [True for _ in range(sieve_size)] # Sieve
primes = [] # List of Primes
if n >= 2:
primes.append(2) # 2 is prime by default
for i in range(sieve_size):
if sieve[i]:
value_at_i = i*2 + 3
primes.append(value_at_i)
for j in range(i, sieve_size, value_at_i):
sieve[j] = False
return primes
|
[
"def",
"get_primes",
"(",
"n",
")",
":",
"if",
"n",
"<=",
"0",
":",
"raise",
"ValueError",
"(",
"\"'n' must be a positive integer.\"",
")",
"# If x is even, exclude x from list (-1):",
"sieve_size",
"=",
"(",
"n",
"//",
"2",
"-",
"1",
")",
"if",
"n",
"%",
"2",
"==",
"0",
"else",
"(",
"n",
"//",
"2",
")",
"sieve",
"=",
"[",
"True",
"for",
"_",
"in",
"range",
"(",
"sieve_size",
")",
"]",
"# Sieve",
"primes",
"=",
"[",
"]",
"# List of Primes",
"if",
"n",
">=",
"2",
":",
"primes",
".",
"append",
"(",
"2",
")",
"# 2 is prime by default",
"for",
"i",
"in",
"range",
"(",
"sieve_size",
")",
":",
"if",
"sieve",
"[",
"i",
"]",
":",
"value_at_i",
"=",
"i",
"*",
"2",
"+",
"3",
"primes",
".",
"append",
"(",
"value_at_i",
")",
"for",
"j",
"in",
"range",
"(",
"i",
",",
"sieve_size",
",",
"value_at_i",
")",
":",
"sieve",
"[",
"j",
"]",
"=",
"False",
"return",
"primes"
] |
Return list of all primes less than n,
Using sieve of Eratosthenes.
|
[
"Return",
"list",
"of",
"all",
"primes",
"less",
"than",
"n",
"Using",
"sieve",
"of",
"Eratosthenes",
"."
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/maths/primes_sieve_of_eratosthenes.py#L28-L46
|
train
|
keon/algorithms
|
algorithms/backtrack/permute.py
|
permute
|
def permute(elements):
"""
returns a list with the permuations.
"""
if len(elements) <= 1:
return [elements]
else:
tmp = []
for perm in permute(elements[1:]):
for i in range(len(elements)):
tmp.append(perm[:i] + elements[0:1] + perm[i:])
return tmp
|
python
|
def permute(elements):
"""
returns a list with the permuations.
"""
if len(elements) <= 1:
return [elements]
else:
tmp = []
for perm in permute(elements[1:]):
for i in range(len(elements)):
tmp.append(perm[:i] + elements[0:1] + perm[i:])
return tmp
|
[
"def",
"permute",
"(",
"elements",
")",
":",
"if",
"len",
"(",
"elements",
")",
"<=",
"1",
":",
"return",
"[",
"elements",
"]",
"else",
":",
"tmp",
"=",
"[",
"]",
"for",
"perm",
"in",
"permute",
"(",
"elements",
"[",
"1",
":",
"]",
")",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"elements",
")",
")",
":",
"tmp",
".",
"append",
"(",
"perm",
"[",
":",
"i",
"]",
"+",
"elements",
"[",
"0",
":",
"1",
"]",
"+",
"perm",
"[",
"i",
":",
"]",
")",
"return",
"tmp"
] |
returns a list with the permuations.
|
[
"returns",
"a",
"list",
"with",
"the",
"permuations",
"."
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/backtrack/permute.py#L17-L28
|
train
|
keon/algorithms
|
algorithms/backtrack/permute.py
|
permute_iter
|
def permute_iter(elements):
"""
iterator: returns a perumation by each call.
"""
if len(elements) <= 1:
yield elements
else:
for perm in permute_iter(elements[1:]):
for i in range(len(elements)):
yield perm[:i] + elements[0:1] + perm[i:]
|
python
|
def permute_iter(elements):
"""
iterator: returns a perumation by each call.
"""
if len(elements) <= 1:
yield elements
else:
for perm in permute_iter(elements[1:]):
for i in range(len(elements)):
yield perm[:i] + elements[0:1] + perm[i:]
|
[
"def",
"permute_iter",
"(",
"elements",
")",
":",
"if",
"len",
"(",
"elements",
")",
"<=",
"1",
":",
"yield",
"elements",
"else",
":",
"for",
"perm",
"in",
"permute_iter",
"(",
"elements",
"[",
"1",
":",
"]",
")",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"elements",
")",
")",
":",
"yield",
"perm",
"[",
":",
"i",
"]",
"+",
"elements",
"[",
"0",
":",
"1",
"]",
"+",
"perm",
"[",
"i",
":",
"]"
] |
iterator: returns a perumation by each call.
|
[
"iterator",
":",
"returns",
"a",
"perumation",
"by",
"each",
"call",
"."
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/backtrack/permute.py#L31-L40
|
train
|
keon/algorithms
|
algorithms/maths/extended_gcd.py
|
extended_gcd
|
def extended_gcd(a, b):
"""Extended GCD algorithm.
Return s, t, g
such that a * s + b * t = GCD(a, b)
and s and t are co-prime.
"""
old_s, s = 1, 0
old_t, t = 0, 1
old_r, r = a, b
while r != 0:
quotient = old_r / r
old_r, r = r, old_r - quotient * r
old_s, s = s, old_s - quotient * s
old_t, t = t, old_t - quotient * t
return old_s, old_t, old_r
|
python
|
def extended_gcd(a, b):
"""Extended GCD algorithm.
Return s, t, g
such that a * s + b * t = GCD(a, b)
and s and t are co-prime.
"""
old_s, s = 1, 0
old_t, t = 0, 1
old_r, r = a, b
while r != 0:
quotient = old_r / r
old_r, r = r, old_r - quotient * r
old_s, s = s, old_s - quotient * s
old_t, t = t, old_t - quotient * t
return old_s, old_t, old_r
|
[
"def",
"extended_gcd",
"(",
"a",
",",
"b",
")",
":",
"old_s",
",",
"s",
"=",
"1",
",",
"0",
"old_t",
",",
"t",
"=",
"0",
",",
"1",
"old_r",
",",
"r",
"=",
"a",
",",
"b",
"while",
"r",
"!=",
"0",
":",
"quotient",
"=",
"old_r",
"/",
"r",
"old_r",
",",
"r",
"=",
"r",
",",
"old_r",
"-",
"quotient",
"*",
"r",
"old_s",
",",
"s",
"=",
"s",
",",
"old_s",
"-",
"quotient",
"*",
"s",
"old_t",
",",
"t",
"=",
"t",
",",
"old_t",
"-",
"quotient",
"*",
"t",
"return",
"old_s",
",",
"old_t",
",",
"old_r"
] |
Extended GCD algorithm.
Return s, t, g
such that a * s + b * t = GCD(a, b)
and s and t are co-prime.
|
[
"Extended",
"GCD",
"algorithm",
".",
"Return",
"s",
"t",
"g",
"such",
"that",
"a",
"*",
"s",
"+",
"b",
"*",
"t",
"=",
"GCD",
"(",
"a",
"b",
")",
"and",
"s",
"and",
"t",
"are",
"co",
"-",
"prime",
"."
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/maths/extended_gcd.py#L1-L19
|
train
|
keon/algorithms
|
algorithms/tree/bin_tree_to_list.py
|
bin_tree_to_list
|
def bin_tree_to_list(root):
"""
type root: root class
"""
if not root:
return root
root = bin_tree_to_list_util(root)
while root.left:
root = root.left
return root
|
python
|
def bin_tree_to_list(root):
"""
type root: root class
"""
if not root:
return root
root = bin_tree_to_list_util(root)
while root.left:
root = root.left
return root
|
[
"def",
"bin_tree_to_list",
"(",
"root",
")",
":",
"if",
"not",
"root",
":",
"return",
"root",
"root",
"=",
"bin_tree_to_list_util",
"(",
"root",
")",
"while",
"root",
".",
"left",
":",
"root",
"=",
"root",
".",
"left",
"return",
"root"
] |
type root: root class
|
[
"type",
"root",
":",
"root",
"class"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/tree/bin_tree_to_list.py#L4-L13
|
train
|
keon/algorithms
|
algorithms/backtrack/add_operators.py
|
add_operators
|
def add_operators(num, target):
"""
:type num: str
:type target: int
:rtype: List[str]
"""
def dfs(res, path, num, target, pos, prev, multed):
if pos == len(num):
if target == prev:
res.append(path)
return
for i in range(pos, len(num)):
if i != pos and num[pos] == '0': # all digits have to be used
break
cur = int(num[pos:i+1])
if pos == 0:
dfs(res, path + str(cur), num, target, i+1, cur, cur)
else:
dfs(res, path + "+" + str(cur), num, target,
i+1, prev + cur, cur)
dfs(res, path + "-" + str(cur), num, target,
i+1, prev - cur, -cur)
dfs(res, path + "*" + str(cur), num, target,
i+1, prev - multed + multed * cur, multed * cur)
res = []
if not num:
return res
dfs(res, "", num, target, 0, 0, 0)
return res
|
python
|
def add_operators(num, target):
"""
:type num: str
:type target: int
:rtype: List[str]
"""
def dfs(res, path, num, target, pos, prev, multed):
if pos == len(num):
if target == prev:
res.append(path)
return
for i in range(pos, len(num)):
if i != pos and num[pos] == '0': # all digits have to be used
break
cur = int(num[pos:i+1])
if pos == 0:
dfs(res, path + str(cur), num, target, i+1, cur, cur)
else:
dfs(res, path + "+" + str(cur), num, target,
i+1, prev + cur, cur)
dfs(res, path + "-" + str(cur), num, target,
i+1, prev - cur, -cur)
dfs(res, path + "*" + str(cur), num, target,
i+1, prev - multed + multed * cur, multed * cur)
res = []
if not num:
return res
dfs(res, "", num, target, 0, 0, 0)
return res
|
[
"def",
"add_operators",
"(",
"num",
",",
"target",
")",
":",
"def",
"dfs",
"(",
"res",
",",
"path",
",",
"num",
",",
"target",
",",
"pos",
",",
"prev",
",",
"multed",
")",
":",
"if",
"pos",
"==",
"len",
"(",
"num",
")",
":",
"if",
"target",
"==",
"prev",
":",
"res",
".",
"append",
"(",
"path",
")",
"return",
"for",
"i",
"in",
"range",
"(",
"pos",
",",
"len",
"(",
"num",
")",
")",
":",
"if",
"i",
"!=",
"pos",
"and",
"num",
"[",
"pos",
"]",
"==",
"'0'",
":",
"# all digits have to be used",
"break",
"cur",
"=",
"int",
"(",
"num",
"[",
"pos",
":",
"i",
"+",
"1",
"]",
")",
"if",
"pos",
"==",
"0",
":",
"dfs",
"(",
"res",
",",
"path",
"+",
"str",
"(",
"cur",
")",
",",
"num",
",",
"target",
",",
"i",
"+",
"1",
",",
"cur",
",",
"cur",
")",
"else",
":",
"dfs",
"(",
"res",
",",
"path",
"+",
"\"+\"",
"+",
"str",
"(",
"cur",
")",
",",
"num",
",",
"target",
",",
"i",
"+",
"1",
",",
"prev",
"+",
"cur",
",",
"cur",
")",
"dfs",
"(",
"res",
",",
"path",
"+",
"\"-\"",
"+",
"str",
"(",
"cur",
")",
",",
"num",
",",
"target",
",",
"i",
"+",
"1",
",",
"prev",
"-",
"cur",
",",
"-",
"cur",
")",
"dfs",
"(",
"res",
",",
"path",
"+",
"\"*\"",
"+",
"str",
"(",
"cur",
")",
",",
"num",
",",
"target",
",",
"i",
"+",
"1",
",",
"prev",
"-",
"multed",
"+",
"multed",
"*",
"cur",
",",
"multed",
"*",
"cur",
")",
"res",
"=",
"[",
"]",
"if",
"not",
"num",
":",
"return",
"res",
"dfs",
"(",
"res",
",",
"\"\"",
",",
"num",
",",
"target",
",",
"0",
",",
"0",
",",
"0",
")",
"return",
"res"
] |
:type num: str
:type target: int
:rtype: List[str]
|
[
":",
"type",
"num",
":",
"str",
":",
"type",
"target",
":",
"int",
":",
"rtype",
":",
"List",
"[",
"str",
"]"
] |
4d6569464a62a75c1357acc97e2dd32ee2f9f4a3
|
https://github.com/keon/algorithms/blob/4d6569464a62a75c1357acc97e2dd32ee2f9f4a3/algorithms/backtrack/add_operators.py#L15-L45
|
train
|
dmlc/xgboost
|
python-package/xgboost/rabit.py
|
_init_rabit
|
def _init_rabit():
"""internal library initializer."""
if _LIB is not None:
_LIB.RabitGetRank.restype = ctypes.c_int
_LIB.RabitGetWorldSize.restype = ctypes.c_int
_LIB.RabitIsDistributed.restype = ctypes.c_int
_LIB.RabitVersionNumber.restype = ctypes.c_int
|
python
|
def _init_rabit():
"""internal library initializer."""
if _LIB is not None:
_LIB.RabitGetRank.restype = ctypes.c_int
_LIB.RabitGetWorldSize.restype = ctypes.c_int
_LIB.RabitIsDistributed.restype = ctypes.c_int
_LIB.RabitVersionNumber.restype = ctypes.c_int
|
[
"def",
"_init_rabit",
"(",
")",
":",
"if",
"_LIB",
"is",
"not",
"None",
":",
"_LIB",
".",
"RabitGetRank",
".",
"restype",
"=",
"ctypes",
".",
"c_int",
"_LIB",
".",
"RabitGetWorldSize",
".",
"restype",
"=",
"ctypes",
".",
"c_int",
"_LIB",
".",
"RabitIsDistributed",
".",
"restype",
"=",
"ctypes",
".",
"c_int",
"_LIB",
".",
"RabitVersionNumber",
".",
"restype",
"=",
"ctypes",
".",
"c_int"
] |
internal library initializer.
|
[
"internal",
"library",
"initializer",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/rabit.py#L14-L20
|
train
|
dmlc/xgboost
|
python-package/xgboost/rabit.py
|
init
|
def init(args=None):
"""Initialize the rabit library with arguments"""
if args is None:
args = []
arr = (ctypes.c_char_p * len(args))()
arr[:] = args
_LIB.RabitInit(len(arr), arr)
|
python
|
def init(args=None):
"""Initialize the rabit library with arguments"""
if args is None:
args = []
arr = (ctypes.c_char_p * len(args))()
arr[:] = args
_LIB.RabitInit(len(arr), arr)
|
[
"def",
"init",
"(",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"None",
":",
"args",
"=",
"[",
"]",
"arr",
"=",
"(",
"ctypes",
".",
"c_char_p",
"*",
"len",
"(",
"args",
")",
")",
"(",
")",
"arr",
"[",
":",
"]",
"=",
"args",
"_LIB",
".",
"RabitInit",
"(",
"len",
"(",
"arr",
")",
",",
"arr",
")"
] |
Initialize the rabit library with arguments
|
[
"Initialize",
"the",
"rabit",
"library",
"with",
"arguments"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/rabit.py#L23-L29
|
train
|
dmlc/xgboost
|
python-package/xgboost/rabit.py
|
tracker_print
|
def tracker_print(msg):
"""Print message to the tracker.
This function can be used to communicate the information of
the progress to the tracker
Parameters
----------
msg : str
The message to be printed to tracker.
"""
if not isinstance(msg, STRING_TYPES):
msg = str(msg)
is_dist = _LIB.RabitIsDistributed()
if is_dist != 0:
_LIB.RabitTrackerPrint(c_str(msg))
else:
sys.stdout.write(msg)
sys.stdout.flush()
|
python
|
def tracker_print(msg):
"""Print message to the tracker.
This function can be used to communicate the information of
the progress to the tracker
Parameters
----------
msg : str
The message to be printed to tracker.
"""
if not isinstance(msg, STRING_TYPES):
msg = str(msg)
is_dist = _LIB.RabitIsDistributed()
if is_dist != 0:
_LIB.RabitTrackerPrint(c_str(msg))
else:
sys.stdout.write(msg)
sys.stdout.flush()
|
[
"def",
"tracker_print",
"(",
"msg",
")",
":",
"if",
"not",
"isinstance",
"(",
"msg",
",",
"STRING_TYPES",
")",
":",
"msg",
"=",
"str",
"(",
"msg",
")",
"is_dist",
"=",
"_LIB",
".",
"RabitIsDistributed",
"(",
")",
"if",
"is_dist",
"!=",
"0",
":",
"_LIB",
".",
"RabitTrackerPrint",
"(",
"c_str",
"(",
"msg",
")",
")",
"else",
":",
"sys",
".",
"stdout",
".",
"write",
"(",
"msg",
")",
"sys",
".",
"stdout",
".",
"flush",
"(",
")"
] |
Print message to the tracker.
This function can be used to communicate the information of
the progress to the tracker
Parameters
----------
msg : str
The message to be printed to tracker.
|
[
"Print",
"message",
"to",
"the",
"tracker",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/rabit.py#L61-L79
|
train
|
dmlc/xgboost
|
python-package/xgboost/rabit.py
|
get_processor_name
|
def get_processor_name():
"""Get the processor name.
Returns
-------
name : str
the name of processor(host)
"""
mxlen = 256
length = ctypes.c_ulong()
buf = ctypes.create_string_buffer(mxlen)
_LIB.RabitGetProcessorName(buf, ctypes.byref(length), mxlen)
return buf.value
|
python
|
def get_processor_name():
"""Get the processor name.
Returns
-------
name : str
the name of processor(host)
"""
mxlen = 256
length = ctypes.c_ulong()
buf = ctypes.create_string_buffer(mxlen)
_LIB.RabitGetProcessorName(buf, ctypes.byref(length), mxlen)
return buf.value
|
[
"def",
"get_processor_name",
"(",
")",
":",
"mxlen",
"=",
"256",
"length",
"=",
"ctypes",
".",
"c_ulong",
"(",
")",
"buf",
"=",
"ctypes",
".",
"create_string_buffer",
"(",
"mxlen",
")",
"_LIB",
".",
"RabitGetProcessorName",
"(",
"buf",
",",
"ctypes",
".",
"byref",
"(",
"length",
")",
",",
"mxlen",
")",
"return",
"buf",
".",
"value"
] |
Get the processor name.
Returns
-------
name : str
the name of processor(host)
|
[
"Get",
"the",
"processor",
"name",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/rabit.py#L82-L94
|
train
|
dmlc/xgboost
|
python-package/xgboost/rabit.py
|
broadcast
|
def broadcast(data, root):
"""Broadcast object from one node to all other nodes.
Parameters
----------
data : any type that can be pickled
Input data, if current rank does not equal root, this can be None
root : int
Rank of the node to broadcast data from.
Returns
-------
object : int
the result of broadcast.
"""
rank = get_rank()
length = ctypes.c_ulong()
if root == rank:
assert data is not None, 'need to pass in data when broadcasting'
s = pickle.dumps(data, protocol=pickle.HIGHEST_PROTOCOL)
length.value = len(s)
# run first broadcast
_LIB.RabitBroadcast(ctypes.byref(length),
ctypes.sizeof(ctypes.c_ulong), root)
if root != rank:
dptr = (ctypes.c_char * length.value)()
# run second
_LIB.RabitBroadcast(ctypes.cast(dptr, ctypes.c_void_p),
length.value, root)
data = pickle.loads(dptr.raw)
del dptr
else:
_LIB.RabitBroadcast(ctypes.cast(ctypes.c_char_p(s), ctypes.c_void_p),
length.value, root)
del s
return data
|
python
|
def broadcast(data, root):
"""Broadcast object from one node to all other nodes.
Parameters
----------
data : any type that can be pickled
Input data, if current rank does not equal root, this can be None
root : int
Rank of the node to broadcast data from.
Returns
-------
object : int
the result of broadcast.
"""
rank = get_rank()
length = ctypes.c_ulong()
if root == rank:
assert data is not None, 'need to pass in data when broadcasting'
s = pickle.dumps(data, protocol=pickle.HIGHEST_PROTOCOL)
length.value = len(s)
# run first broadcast
_LIB.RabitBroadcast(ctypes.byref(length),
ctypes.sizeof(ctypes.c_ulong), root)
if root != rank:
dptr = (ctypes.c_char * length.value)()
# run second
_LIB.RabitBroadcast(ctypes.cast(dptr, ctypes.c_void_p),
length.value, root)
data = pickle.loads(dptr.raw)
del dptr
else:
_LIB.RabitBroadcast(ctypes.cast(ctypes.c_char_p(s), ctypes.c_void_p),
length.value, root)
del s
return data
|
[
"def",
"broadcast",
"(",
"data",
",",
"root",
")",
":",
"rank",
"=",
"get_rank",
"(",
")",
"length",
"=",
"ctypes",
".",
"c_ulong",
"(",
")",
"if",
"root",
"==",
"rank",
":",
"assert",
"data",
"is",
"not",
"None",
",",
"'need to pass in data when broadcasting'",
"s",
"=",
"pickle",
".",
"dumps",
"(",
"data",
",",
"protocol",
"=",
"pickle",
".",
"HIGHEST_PROTOCOL",
")",
"length",
".",
"value",
"=",
"len",
"(",
"s",
")",
"# run first broadcast",
"_LIB",
".",
"RabitBroadcast",
"(",
"ctypes",
".",
"byref",
"(",
"length",
")",
",",
"ctypes",
".",
"sizeof",
"(",
"ctypes",
".",
"c_ulong",
")",
",",
"root",
")",
"if",
"root",
"!=",
"rank",
":",
"dptr",
"=",
"(",
"ctypes",
".",
"c_char",
"*",
"length",
".",
"value",
")",
"(",
")",
"# run second",
"_LIB",
".",
"RabitBroadcast",
"(",
"ctypes",
".",
"cast",
"(",
"dptr",
",",
"ctypes",
".",
"c_void_p",
")",
",",
"length",
".",
"value",
",",
"root",
")",
"data",
"=",
"pickle",
".",
"loads",
"(",
"dptr",
".",
"raw",
")",
"del",
"dptr",
"else",
":",
"_LIB",
".",
"RabitBroadcast",
"(",
"ctypes",
".",
"cast",
"(",
"ctypes",
".",
"c_char_p",
"(",
"s",
")",
",",
"ctypes",
".",
"c_void_p",
")",
",",
"length",
".",
"value",
",",
"root",
")",
"del",
"s",
"return",
"data"
] |
Broadcast object from one node to all other nodes.
Parameters
----------
data : any type that can be pickled
Input data, if current rank does not equal root, this can be None
root : int
Rank of the node to broadcast data from.
Returns
-------
object : int
the result of broadcast.
|
[
"Broadcast",
"object",
"from",
"one",
"node",
"to",
"all",
"other",
"nodes",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/rabit.py#L97-L132
|
train
|
dmlc/xgboost
|
jvm-packages/create_jni.py
|
normpath
|
def normpath(path):
"""Normalize UNIX path to a native path."""
normalized = os.path.join(*path.split("/"))
if os.path.isabs(path):
return os.path.abspath("/") + normalized
else:
return normalized
|
python
|
def normpath(path):
"""Normalize UNIX path to a native path."""
normalized = os.path.join(*path.split("/"))
if os.path.isabs(path):
return os.path.abspath("/") + normalized
else:
return normalized
|
[
"def",
"normpath",
"(",
"path",
")",
":",
"normalized",
"=",
"os",
".",
"path",
".",
"join",
"(",
"*",
"path",
".",
"split",
"(",
"\"/\"",
")",
")",
"if",
"os",
".",
"path",
".",
"isabs",
"(",
"path",
")",
":",
"return",
"os",
".",
"path",
".",
"abspath",
"(",
"\"/\"",
")",
"+",
"normalized",
"else",
":",
"return",
"normalized"
] |
Normalize UNIX path to a native path.
|
[
"Normalize",
"UNIX",
"path",
"to",
"a",
"native",
"path",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/jvm-packages/create_jni.py#L61-L67
|
train
|
dmlc/xgboost
|
python-package/xgboost/training.py
|
_train_internal
|
def _train_internal(params, dtrain,
num_boost_round=10, evals=(),
obj=None, feval=None,
xgb_model=None, callbacks=None):
"""internal training function"""
callbacks = [] if callbacks is None else callbacks
evals = list(evals)
if isinstance(params, dict) \
and 'eval_metric' in params \
and isinstance(params['eval_metric'], list):
params = dict((k, v) for k, v in params.items())
eval_metrics = params['eval_metric']
params.pop("eval_metric", None)
params = list(params.items())
for eval_metric in eval_metrics:
params += [('eval_metric', eval_metric)]
bst = Booster(params, [dtrain] + [d[0] for d in evals])
nboost = 0
num_parallel_tree = 1
if xgb_model is not None:
if not isinstance(xgb_model, STRING_TYPES):
xgb_model = xgb_model.save_raw()
bst = Booster(params, [dtrain] + [d[0] for d in evals], model_file=xgb_model)
nboost = len(bst.get_dump())
_params = dict(params) if isinstance(params, list) else params
if 'num_parallel_tree' in _params:
num_parallel_tree = _params['num_parallel_tree']
nboost //= num_parallel_tree
if 'num_class' in _params:
nboost //= _params['num_class']
# Distributed code: Load the checkpoint from rabit.
version = bst.load_rabit_checkpoint()
assert rabit.get_world_size() != 1 or version == 0
rank = rabit.get_rank()
start_iteration = int(version / 2)
nboost += start_iteration
callbacks_before_iter = [
cb for cb in callbacks if cb.__dict__.get('before_iteration', False)]
callbacks_after_iter = [
cb for cb in callbacks if not cb.__dict__.get('before_iteration', False)]
for i in range(start_iteration, num_boost_round):
for cb in callbacks_before_iter:
cb(CallbackEnv(model=bst,
cvfolds=None,
iteration=i,
begin_iteration=start_iteration,
end_iteration=num_boost_round,
rank=rank,
evaluation_result_list=None))
# Distributed code: need to resume to this point.
# Skip the first update if it is a recovery step.
if version % 2 == 0:
bst.update(dtrain, i, obj)
bst.save_rabit_checkpoint()
version += 1
assert rabit.get_world_size() == 1 or version == rabit.version_number()
nboost += 1
evaluation_result_list = []
# check evaluation result.
if evals:
bst_eval_set = bst.eval_set(evals, i, feval)
if isinstance(bst_eval_set, STRING_TYPES):
msg = bst_eval_set
else:
msg = bst_eval_set.decode()
res = [x.split(':') for x in msg.split()]
evaluation_result_list = [(k, float(v)) for k, v in res[1:]]
try:
for cb in callbacks_after_iter:
cb(CallbackEnv(model=bst,
cvfolds=None,
iteration=i,
begin_iteration=start_iteration,
end_iteration=num_boost_round,
rank=rank,
evaluation_result_list=evaluation_result_list))
except EarlyStopException:
break
# do checkpoint after evaluation, in case evaluation also updates booster.
bst.save_rabit_checkpoint()
version += 1
if bst.attr('best_score') is not None:
bst.best_score = float(bst.attr('best_score'))
bst.best_iteration = int(bst.attr('best_iteration'))
else:
bst.best_iteration = nboost - 1
bst.best_ntree_limit = (bst.best_iteration + 1) * num_parallel_tree
return bst
|
python
|
def _train_internal(params, dtrain,
num_boost_round=10, evals=(),
obj=None, feval=None,
xgb_model=None, callbacks=None):
"""internal training function"""
callbacks = [] if callbacks is None else callbacks
evals = list(evals)
if isinstance(params, dict) \
and 'eval_metric' in params \
and isinstance(params['eval_metric'], list):
params = dict((k, v) for k, v in params.items())
eval_metrics = params['eval_metric']
params.pop("eval_metric", None)
params = list(params.items())
for eval_metric in eval_metrics:
params += [('eval_metric', eval_metric)]
bst = Booster(params, [dtrain] + [d[0] for d in evals])
nboost = 0
num_parallel_tree = 1
if xgb_model is not None:
if not isinstance(xgb_model, STRING_TYPES):
xgb_model = xgb_model.save_raw()
bst = Booster(params, [dtrain] + [d[0] for d in evals], model_file=xgb_model)
nboost = len(bst.get_dump())
_params = dict(params) if isinstance(params, list) else params
if 'num_parallel_tree' in _params:
num_parallel_tree = _params['num_parallel_tree']
nboost //= num_parallel_tree
if 'num_class' in _params:
nboost //= _params['num_class']
# Distributed code: Load the checkpoint from rabit.
version = bst.load_rabit_checkpoint()
assert rabit.get_world_size() != 1 or version == 0
rank = rabit.get_rank()
start_iteration = int(version / 2)
nboost += start_iteration
callbacks_before_iter = [
cb for cb in callbacks if cb.__dict__.get('before_iteration', False)]
callbacks_after_iter = [
cb for cb in callbacks if not cb.__dict__.get('before_iteration', False)]
for i in range(start_iteration, num_boost_round):
for cb in callbacks_before_iter:
cb(CallbackEnv(model=bst,
cvfolds=None,
iteration=i,
begin_iteration=start_iteration,
end_iteration=num_boost_round,
rank=rank,
evaluation_result_list=None))
# Distributed code: need to resume to this point.
# Skip the first update if it is a recovery step.
if version % 2 == 0:
bst.update(dtrain, i, obj)
bst.save_rabit_checkpoint()
version += 1
assert rabit.get_world_size() == 1 or version == rabit.version_number()
nboost += 1
evaluation_result_list = []
# check evaluation result.
if evals:
bst_eval_set = bst.eval_set(evals, i, feval)
if isinstance(bst_eval_set, STRING_TYPES):
msg = bst_eval_set
else:
msg = bst_eval_set.decode()
res = [x.split(':') for x in msg.split()]
evaluation_result_list = [(k, float(v)) for k, v in res[1:]]
try:
for cb in callbacks_after_iter:
cb(CallbackEnv(model=bst,
cvfolds=None,
iteration=i,
begin_iteration=start_iteration,
end_iteration=num_boost_round,
rank=rank,
evaluation_result_list=evaluation_result_list))
except EarlyStopException:
break
# do checkpoint after evaluation, in case evaluation also updates booster.
bst.save_rabit_checkpoint()
version += 1
if bst.attr('best_score') is not None:
bst.best_score = float(bst.attr('best_score'))
bst.best_iteration = int(bst.attr('best_iteration'))
else:
bst.best_iteration = nboost - 1
bst.best_ntree_limit = (bst.best_iteration + 1) * num_parallel_tree
return bst
|
[
"def",
"_train_internal",
"(",
"params",
",",
"dtrain",
",",
"num_boost_round",
"=",
"10",
",",
"evals",
"=",
"(",
")",
",",
"obj",
"=",
"None",
",",
"feval",
"=",
"None",
",",
"xgb_model",
"=",
"None",
",",
"callbacks",
"=",
"None",
")",
":",
"callbacks",
"=",
"[",
"]",
"if",
"callbacks",
"is",
"None",
"else",
"callbacks",
"evals",
"=",
"list",
"(",
"evals",
")",
"if",
"isinstance",
"(",
"params",
",",
"dict",
")",
"and",
"'eval_metric'",
"in",
"params",
"and",
"isinstance",
"(",
"params",
"[",
"'eval_metric'",
"]",
",",
"list",
")",
":",
"params",
"=",
"dict",
"(",
"(",
"k",
",",
"v",
")",
"for",
"k",
",",
"v",
"in",
"params",
".",
"items",
"(",
")",
")",
"eval_metrics",
"=",
"params",
"[",
"'eval_metric'",
"]",
"params",
".",
"pop",
"(",
"\"eval_metric\"",
",",
"None",
")",
"params",
"=",
"list",
"(",
"params",
".",
"items",
"(",
")",
")",
"for",
"eval_metric",
"in",
"eval_metrics",
":",
"params",
"+=",
"[",
"(",
"'eval_metric'",
",",
"eval_metric",
")",
"]",
"bst",
"=",
"Booster",
"(",
"params",
",",
"[",
"dtrain",
"]",
"+",
"[",
"d",
"[",
"0",
"]",
"for",
"d",
"in",
"evals",
"]",
")",
"nboost",
"=",
"0",
"num_parallel_tree",
"=",
"1",
"if",
"xgb_model",
"is",
"not",
"None",
":",
"if",
"not",
"isinstance",
"(",
"xgb_model",
",",
"STRING_TYPES",
")",
":",
"xgb_model",
"=",
"xgb_model",
".",
"save_raw",
"(",
")",
"bst",
"=",
"Booster",
"(",
"params",
",",
"[",
"dtrain",
"]",
"+",
"[",
"d",
"[",
"0",
"]",
"for",
"d",
"in",
"evals",
"]",
",",
"model_file",
"=",
"xgb_model",
")",
"nboost",
"=",
"len",
"(",
"bst",
".",
"get_dump",
"(",
")",
")",
"_params",
"=",
"dict",
"(",
"params",
")",
"if",
"isinstance",
"(",
"params",
",",
"list",
")",
"else",
"params",
"if",
"'num_parallel_tree'",
"in",
"_params",
":",
"num_parallel_tree",
"=",
"_params",
"[",
"'num_parallel_tree'",
"]",
"nboost",
"//=",
"num_parallel_tree",
"if",
"'num_class'",
"in",
"_params",
":",
"nboost",
"//=",
"_params",
"[",
"'num_class'",
"]",
"# Distributed code: Load the checkpoint from rabit.",
"version",
"=",
"bst",
".",
"load_rabit_checkpoint",
"(",
")",
"assert",
"rabit",
".",
"get_world_size",
"(",
")",
"!=",
"1",
"or",
"version",
"==",
"0",
"rank",
"=",
"rabit",
".",
"get_rank",
"(",
")",
"start_iteration",
"=",
"int",
"(",
"version",
"/",
"2",
")",
"nboost",
"+=",
"start_iteration",
"callbacks_before_iter",
"=",
"[",
"cb",
"for",
"cb",
"in",
"callbacks",
"if",
"cb",
".",
"__dict__",
".",
"get",
"(",
"'before_iteration'",
",",
"False",
")",
"]",
"callbacks_after_iter",
"=",
"[",
"cb",
"for",
"cb",
"in",
"callbacks",
"if",
"not",
"cb",
".",
"__dict__",
".",
"get",
"(",
"'before_iteration'",
",",
"False",
")",
"]",
"for",
"i",
"in",
"range",
"(",
"start_iteration",
",",
"num_boost_round",
")",
":",
"for",
"cb",
"in",
"callbacks_before_iter",
":",
"cb",
"(",
"CallbackEnv",
"(",
"model",
"=",
"bst",
",",
"cvfolds",
"=",
"None",
",",
"iteration",
"=",
"i",
",",
"begin_iteration",
"=",
"start_iteration",
",",
"end_iteration",
"=",
"num_boost_round",
",",
"rank",
"=",
"rank",
",",
"evaluation_result_list",
"=",
"None",
")",
")",
"# Distributed code: need to resume to this point.",
"# Skip the first update if it is a recovery step.",
"if",
"version",
"%",
"2",
"==",
"0",
":",
"bst",
".",
"update",
"(",
"dtrain",
",",
"i",
",",
"obj",
")",
"bst",
".",
"save_rabit_checkpoint",
"(",
")",
"version",
"+=",
"1",
"assert",
"rabit",
".",
"get_world_size",
"(",
")",
"==",
"1",
"or",
"version",
"==",
"rabit",
".",
"version_number",
"(",
")",
"nboost",
"+=",
"1",
"evaluation_result_list",
"=",
"[",
"]",
"# check evaluation result.",
"if",
"evals",
":",
"bst_eval_set",
"=",
"bst",
".",
"eval_set",
"(",
"evals",
",",
"i",
",",
"feval",
")",
"if",
"isinstance",
"(",
"bst_eval_set",
",",
"STRING_TYPES",
")",
":",
"msg",
"=",
"bst_eval_set",
"else",
":",
"msg",
"=",
"bst_eval_set",
".",
"decode",
"(",
")",
"res",
"=",
"[",
"x",
".",
"split",
"(",
"':'",
")",
"for",
"x",
"in",
"msg",
".",
"split",
"(",
")",
"]",
"evaluation_result_list",
"=",
"[",
"(",
"k",
",",
"float",
"(",
"v",
")",
")",
"for",
"k",
",",
"v",
"in",
"res",
"[",
"1",
":",
"]",
"]",
"try",
":",
"for",
"cb",
"in",
"callbacks_after_iter",
":",
"cb",
"(",
"CallbackEnv",
"(",
"model",
"=",
"bst",
",",
"cvfolds",
"=",
"None",
",",
"iteration",
"=",
"i",
",",
"begin_iteration",
"=",
"start_iteration",
",",
"end_iteration",
"=",
"num_boost_round",
",",
"rank",
"=",
"rank",
",",
"evaluation_result_list",
"=",
"evaluation_result_list",
")",
")",
"except",
"EarlyStopException",
":",
"break",
"# do checkpoint after evaluation, in case evaluation also updates booster.",
"bst",
".",
"save_rabit_checkpoint",
"(",
")",
"version",
"+=",
"1",
"if",
"bst",
".",
"attr",
"(",
"'best_score'",
")",
"is",
"not",
"None",
":",
"bst",
".",
"best_score",
"=",
"float",
"(",
"bst",
".",
"attr",
"(",
"'best_score'",
")",
")",
"bst",
".",
"best_iteration",
"=",
"int",
"(",
"bst",
".",
"attr",
"(",
"'best_iteration'",
")",
")",
"else",
":",
"bst",
".",
"best_iteration",
"=",
"nboost",
"-",
"1",
"bst",
".",
"best_ntree_limit",
"=",
"(",
"bst",
".",
"best_iteration",
"+",
"1",
")",
"*",
"num_parallel_tree",
"return",
"bst"
] |
internal training function
|
[
"internal",
"training",
"function"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/training.py#L15-L112
|
train
|
dmlc/xgboost
|
python-package/xgboost/training.py
|
train
|
def train(params, dtrain, num_boost_round=10, evals=(), obj=None, feval=None,
maximize=False, early_stopping_rounds=None, evals_result=None,
verbose_eval=True, xgb_model=None, callbacks=None, learning_rates=None):
# pylint: disable=too-many-statements,too-many-branches, attribute-defined-outside-init
"""Train a booster with given parameters.
Parameters
----------
params : dict
Booster params.
dtrain : DMatrix
Data to be trained.
num_boost_round: int
Number of boosting iterations.
evals: list of pairs (DMatrix, string)
List of items to be evaluated during training, this allows user to watch
performance on the validation set.
obj : function
Customized objective function.
feval : function
Customized evaluation function.
maximize : bool
Whether to maximize feval.
early_stopping_rounds: int
Activates early stopping. Validation error needs to decrease at least
every **early_stopping_rounds** round(s) to continue training.
Requires at least one item in **evals**.
If there's more than one, will use the last.
Returns the model from the last iteration (not the best one).
If early stopping occurs, the model will have three additional fields:
``bst.best_score``, ``bst.best_iteration`` and ``bst.best_ntree_limit``.
(Use ``bst.best_ntree_limit`` to get the correct value if
``num_parallel_tree`` and/or ``num_class`` appears in the parameters)
evals_result: dict
This dictionary stores the evaluation results of all the items in watchlist.
Example: with a watchlist containing
``[(dtest,'eval'), (dtrain,'train')]`` and
a parameter containing ``('eval_metric': 'logloss')``,
the **evals_result** returns
.. code-block:: python
{'train': {'logloss': ['0.48253', '0.35953']},
'eval': {'logloss': ['0.480385', '0.357756']}}
verbose_eval : bool or int
Requires at least one item in **evals**.
If **verbose_eval** is True then the evaluation metric on the validation set is
printed at each boosting stage.
If **verbose_eval** is an integer then the evaluation metric on the validation set
is printed at every given **verbose_eval** boosting stage. The last boosting stage
/ the boosting stage found by using **early_stopping_rounds** is also printed.
Example: with ``verbose_eval=4`` and at least one item in **evals**, an evaluation metric
is printed every 4 boosting stages, instead of every boosting stage.
learning_rates: list or function (deprecated - use callback API instead)
List of learning rate for each boosting round
or a customized function that calculates eta in terms of
current number of round and the total number of boosting round (e.g. yields
learning rate decay)
xgb_model : file name of stored xgb model or 'Booster' instance
Xgb model to be loaded before training (allows training continuation).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using
:ref:`Callback API <callback_api>`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
Returns
-------
Booster : a trained booster model
"""
callbacks = [] if callbacks is None else callbacks
# Most of legacy advanced options becomes callbacks
if isinstance(verbose_eval, bool) and verbose_eval:
callbacks.append(callback.print_evaluation())
else:
if isinstance(verbose_eval, int):
callbacks.append(callback.print_evaluation(verbose_eval))
if early_stopping_rounds is not None:
callbacks.append(callback.early_stop(early_stopping_rounds,
maximize=maximize,
verbose=bool(verbose_eval)))
if evals_result is not None:
callbacks.append(callback.record_evaluation(evals_result))
if learning_rates is not None:
warnings.warn("learning_rates parameter is deprecated - use callback API instead",
DeprecationWarning)
callbacks.append(callback.reset_learning_rate(learning_rates))
return _train_internal(params, dtrain,
num_boost_round=num_boost_round,
evals=evals,
obj=obj, feval=feval,
xgb_model=xgb_model, callbacks=callbacks)
|
python
|
def train(params, dtrain, num_boost_round=10, evals=(), obj=None, feval=None,
maximize=False, early_stopping_rounds=None, evals_result=None,
verbose_eval=True, xgb_model=None, callbacks=None, learning_rates=None):
# pylint: disable=too-many-statements,too-many-branches, attribute-defined-outside-init
"""Train a booster with given parameters.
Parameters
----------
params : dict
Booster params.
dtrain : DMatrix
Data to be trained.
num_boost_round: int
Number of boosting iterations.
evals: list of pairs (DMatrix, string)
List of items to be evaluated during training, this allows user to watch
performance on the validation set.
obj : function
Customized objective function.
feval : function
Customized evaluation function.
maximize : bool
Whether to maximize feval.
early_stopping_rounds: int
Activates early stopping. Validation error needs to decrease at least
every **early_stopping_rounds** round(s) to continue training.
Requires at least one item in **evals**.
If there's more than one, will use the last.
Returns the model from the last iteration (not the best one).
If early stopping occurs, the model will have three additional fields:
``bst.best_score``, ``bst.best_iteration`` and ``bst.best_ntree_limit``.
(Use ``bst.best_ntree_limit`` to get the correct value if
``num_parallel_tree`` and/or ``num_class`` appears in the parameters)
evals_result: dict
This dictionary stores the evaluation results of all the items in watchlist.
Example: with a watchlist containing
``[(dtest,'eval'), (dtrain,'train')]`` and
a parameter containing ``('eval_metric': 'logloss')``,
the **evals_result** returns
.. code-block:: python
{'train': {'logloss': ['0.48253', '0.35953']},
'eval': {'logloss': ['0.480385', '0.357756']}}
verbose_eval : bool or int
Requires at least one item in **evals**.
If **verbose_eval** is True then the evaluation metric on the validation set is
printed at each boosting stage.
If **verbose_eval** is an integer then the evaluation metric on the validation set
is printed at every given **verbose_eval** boosting stage. The last boosting stage
/ the boosting stage found by using **early_stopping_rounds** is also printed.
Example: with ``verbose_eval=4`` and at least one item in **evals**, an evaluation metric
is printed every 4 boosting stages, instead of every boosting stage.
learning_rates: list or function (deprecated - use callback API instead)
List of learning rate for each boosting round
or a customized function that calculates eta in terms of
current number of round and the total number of boosting round (e.g. yields
learning rate decay)
xgb_model : file name of stored xgb model or 'Booster' instance
Xgb model to be loaded before training (allows training continuation).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using
:ref:`Callback API <callback_api>`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
Returns
-------
Booster : a trained booster model
"""
callbacks = [] if callbacks is None else callbacks
# Most of legacy advanced options becomes callbacks
if isinstance(verbose_eval, bool) and verbose_eval:
callbacks.append(callback.print_evaluation())
else:
if isinstance(verbose_eval, int):
callbacks.append(callback.print_evaluation(verbose_eval))
if early_stopping_rounds is not None:
callbacks.append(callback.early_stop(early_stopping_rounds,
maximize=maximize,
verbose=bool(verbose_eval)))
if evals_result is not None:
callbacks.append(callback.record_evaluation(evals_result))
if learning_rates is not None:
warnings.warn("learning_rates parameter is deprecated - use callback API instead",
DeprecationWarning)
callbacks.append(callback.reset_learning_rate(learning_rates))
return _train_internal(params, dtrain,
num_boost_round=num_boost_round,
evals=evals,
obj=obj, feval=feval,
xgb_model=xgb_model, callbacks=callbacks)
|
[
"def",
"train",
"(",
"params",
",",
"dtrain",
",",
"num_boost_round",
"=",
"10",
",",
"evals",
"=",
"(",
")",
",",
"obj",
"=",
"None",
",",
"feval",
"=",
"None",
",",
"maximize",
"=",
"False",
",",
"early_stopping_rounds",
"=",
"None",
",",
"evals_result",
"=",
"None",
",",
"verbose_eval",
"=",
"True",
",",
"xgb_model",
"=",
"None",
",",
"callbacks",
"=",
"None",
",",
"learning_rates",
"=",
"None",
")",
":",
"# pylint: disable=too-many-statements,too-many-branches, attribute-defined-outside-init",
"callbacks",
"=",
"[",
"]",
"if",
"callbacks",
"is",
"None",
"else",
"callbacks",
"# Most of legacy advanced options becomes callbacks",
"if",
"isinstance",
"(",
"verbose_eval",
",",
"bool",
")",
"and",
"verbose_eval",
":",
"callbacks",
".",
"append",
"(",
"callback",
".",
"print_evaluation",
"(",
")",
")",
"else",
":",
"if",
"isinstance",
"(",
"verbose_eval",
",",
"int",
")",
":",
"callbacks",
".",
"append",
"(",
"callback",
".",
"print_evaluation",
"(",
"verbose_eval",
")",
")",
"if",
"early_stopping_rounds",
"is",
"not",
"None",
":",
"callbacks",
".",
"append",
"(",
"callback",
".",
"early_stop",
"(",
"early_stopping_rounds",
",",
"maximize",
"=",
"maximize",
",",
"verbose",
"=",
"bool",
"(",
"verbose_eval",
")",
")",
")",
"if",
"evals_result",
"is",
"not",
"None",
":",
"callbacks",
".",
"append",
"(",
"callback",
".",
"record_evaluation",
"(",
"evals_result",
")",
")",
"if",
"learning_rates",
"is",
"not",
"None",
":",
"warnings",
".",
"warn",
"(",
"\"learning_rates parameter is deprecated - use callback API instead\"",
",",
"DeprecationWarning",
")",
"callbacks",
".",
"append",
"(",
"callback",
".",
"reset_learning_rate",
"(",
"learning_rates",
")",
")",
"return",
"_train_internal",
"(",
"params",
",",
"dtrain",
",",
"num_boost_round",
"=",
"num_boost_round",
",",
"evals",
"=",
"evals",
",",
"obj",
"=",
"obj",
",",
"feval",
"=",
"feval",
",",
"xgb_model",
"=",
"xgb_model",
",",
"callbacks",
"=",
"callbacks",
")"
] |
Train a booster with given parameters.
Parameters
----------
params : dict
Booster params.
dtrain : DMatrix
Data to be trained.
num_boost_round: int
Number of boosting iterations.
evals: list of pairs (DMatrix, string)
List of items to be evaluated during training, this allows user to watch
performance on the validation set.
obj : function
Customized objective function.
feval : function
Customized evaluation function.
maximize : bool
Whether to maximize feval.
early_stopping_rounds: int
Activates early stopping. Validation error needs to decrease at least
every **early_stopping_rounds** round(s) to continue training.
Requires at least one item in **evals**.
If there's more than one, will use the last.
Returns the model from the last iteration (not the best one).
If early stopping occurs, the model will have three additional fields:
``bst.best_score``, ``bst.best_iteration`` and ``bst.best_ntree_limit``.
(Use ``bst.best_ntree_limit`` to get the correct value if
``num_parallel_tree`` and/or ``num_class`` appears in the parameters)
evals_result: dict
This dictionary stores the evaluation results of all the items in watchlist.
Example: with a watchlist containing
``[(dtest,'eval'), (dtrain,'train')]`` and
a parameter containing ``('eval_metric': 'logloss')``,
the **evals_result** returns
.. code-block:: python
{'train': {'logloss': ['0.48253', '0.35953']},
'eval': {'logloss': ['0.480385', '0.357756']}}
verbose_eval : bool or int
Requires at least one item in **evals**.
If **verbose_eval** is True then the evaluation metric on the validation set is
printed at each boosting stage.
If **verbose_eval** is an integer then the evaluation metric on the validation set
is printed at every given **verbose_eval** boosting stage. The last boosting stage
/ the boosting stage found by using **early_stopping_rounds** is also printed.
Example: with ``verbose_eval=4`` and at least one item in **evals**, an evaluation metric
is printed every 4 boosting stages, instead of every boosting stage.
learning_rates: list or function (deprecated - use callback API instead)
List of learning rate for each boosting round
or a customized function that calculates eta in terms of
current number of round and the total number of boosting round (e.g. yields
learning rate decay)
xgb_model : file name of stored xgb model or 'Booster' instance
Xgb model to be loaded before training (allows training continuation).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using
:ref:`Callback API <callback_api>`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
Returns
-------
Booster : a trained booster model
|
[
"Train",
"a",
"booster",
"with",
"given",
"parameters",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/training.py#L115-L216
|
train
|
dmlc/xgboost
|
python-package/xgboost/training.py
|
mknfold
|
def mknfold(dall, nfold, param, seed, evals=(), fpreproc=None, stratified=False,
folds=None, shuffle=True):
"""
Make an n-fold list of CVPack from random indices.
"""
evals = list(evals)
np.random.seed(seed)
if stratified is False and folds is None:
# Do standard k-fold cross validation
if shuffle is True:
idx = np.random.permutation(dall.num_row())
else:
idx = np.arange(dall.num_row())
out_idset = np.array_split(idx, nfold)
in_idset = [
np.concatenate([out_idset[i] for i in range(nfold) if k != i])
for k in range(nfold)
]
elif folds is not None:
# Use user specified custom split using indices
try:
in_idset = [x[0] for x in folds]
out_idset = [x[1] for x in folds]
except TypeError:
# Custom stratification using Sklearn KFoldSplit object
splits = list(folds.split(X=dall.get_label(), y=dall.get_label()))
in_idset = [x[0] for x in splits]
out_idset = [x[1] for x in splits]
nfold = len(out_idset)
else:
# Do standard stratefied shuffle k-fold split
sfk = XGBStratifiedKFold(n_splits=nfold, shuffle=True, random_state=seed)
splits = list(sfk.split(X=dall.get_label(), y=dall.get_label()))
in_idset = [x[0] for x in splits]
out_idset = [x[1] for x in splits]
nfold = len(out_idset)
ret = []
for k in range(nfold):
dtrain = dall.slice(in_idset[k])
dtest = dall.slice(out_idset[k])
# run preprocessing on the data set if needed
if fpreproc is not None:
dtrain, dtest, tparam = fpreproc(dtrain, dtest, param.copy())
else:
tparam = param
plst = list(tparam.items()) + [('eval_metric', itm) for itm in evals]
ret.append(CVPack(dtrain, dtest, plst))
return ret
|
python
|
def mknfold(dall, nfold, param, seed, evals=(), fpreproc=None, stratified=False,
folds=None, shuffle=True):
"""
Make an n-fold list of CVPack from random indices.
"""
evals = list(evals)
np.random.seed(seed)
if stratified is False and folds is None:
# Do standard k-fold cross validation
if shuffle is True:
idx = np.random.permutation(dall.num_row())
else:
idx = np.arange(dall.num_row())
out_idset = np.array_split(idx, nfold)
in_idset = [
np.concatenate([out_idset[i] for i in range(nfold) if k != i])
for k in range(nfold)
]
elif folds is not None:
# Use user specified custom split using indices
try:
in_idset = [x[0] for x in folds]
out_idset = [x[1] for x in folds]
except TypeError:
# Custom stratification using Sklearn KFoldSplit object
splits = list(folds.split(X=dall.get_label(), y=dall.get_label()))
in_idset = [x[0] for x in splits]
out_idset = [x[1] for x in splits]
nfold = len(out_idset)
else:
# Do standard stratefied shuffle k-fold split
sfk = XGBStratifiedKFold(n_splits=nfold, shuffle=True, random_state=seed)
splits = list(sfk.split(X=dall.get_label(), y=dall.get_label()))
in_idset = [x[0] for x in splits]
out_idset = [x[1] for x in splits]
nfold = len(out_idset)
ret = []
for k in range(nfold):
dtrain = dall.slice(in_idset[k])
dtest = dall.slice(out_idset[k])
# run preprocessing on the data set if needed
if fpreproc is not None:
dtrain, dtest, tparam = fpreproc(dtrain, dtest, param.copy())
else:
tparam = param
plst = list(tparam.items()) + [('eval_metric', itm) for itm in evals]
ret.append(CVPack(dtrain, dtest, plst))
return ret
|
[
"def",
"mknfold",
"(",
"dall",
",",
"nfold",
",",
"param",
",",
"seed",
",",
"evals",
"=",
"(",
")",
",",
"fpreproc",
"=",
"None",
",",
"stratified",
"=",
"False",
",",
"folds",
"=",
"None",
",",
"shuffle",
"=",
"True",
")",
":",
"evals",
"=",
"list",
"(",
"evals",
")",
"np",
".",
"random",
".",
"seed",
"(",
"seed",
")",
"if",
"stratified",
"is",
"False",
"and",
"folds",
"is",
"None",
":",
"# Do standard k-fold cross validation",
"if",
"shuffle",
"is",
"True",
":",
"idx",
"=",
"np",
".",
"random",
".",
"permutation",
"(",
"dall",
".",
"num_row",
"(",
")",
")",
"else",
":",
"idx",
"=",
"np",
".",
"arange",
"(",
"dall",
".",
"num_row",
"(",
")",
")",
"out_idset",
"=",
"np",
".",
"array_split",
"(",
"idx",
",",
"nfold",
")",
"in_idset",
"=",
"[",
"np",
".",
"concatenate",
"(",
"[",
"out_idset",
"[",
"i",
"]",
"for",
"i",
"in",
"range",
"(",
"nfold",
")",
"if",
"k",
"!=",
"i",
"]",
")",
"for",
"k",
"in",
"range",
"(",
"nfold",
")",
"]",
"elif",
"folds",
"is",
"not",
"None",
":",
"# Use user specified custom split using indices",
"try",
":",
"in_idset",
"=",
"[",
"x",
"[",
"0",
"]",
"for",
"x",
"in",
"folds",
"]",
"out_idset",
"=",
"[",
"x",
"[",
"1",
"]",
"for",
"x",
"in",
"folds",
"]",
"except",
"TypeError",
":",
"# Custom stratification using Sklearn KFoldSplit object",
"splits",
"=",
"list",
"(",
"folds",
".",
"split",
"(",
"X",
"=",
"dall",
".",
"get_label",
"(",
")",
",",
"y",
"=",
"dall",
".",
"get_label",
"(",
")",
")",
")",
"in_idset",
"=",
"[",
"x",
"[",
"0",
"]",
"for",
"x",
"in",
"splits",
"]",
"out_idset",
"=",
"[",
"x",
"[",
"1",
"]",
"for",
"x",
"in",
"splits",
"]",
"nfold",
"=",
"len",
"(",
"out_idset",
")",
"else",
":",
"# Do standard stratefied shuffle k-fold split",
"sfk",
"=",
"XGBStratifiedKFold",
"(",
"n_splits",
"=",
"nfold",
",",
"shuffle",
"=",
"True",
",",
"random_state",
"=",
"seed",
")",
"splits",
"=",
"list",
"(",
"sfk",
".",
"split",
"(",
"X",
"=",
"dall",
".",
"get_label",
"(",
")",
",",
"y",
"=",
"dall",
".",
"get_label",
"(",
")",
")",
")",
"in_idset",
"=",
"[",
"x",
"[",
"0",
"]",
"for",
"x",
"in",
"splits",
"]",
"out_idset",
"=",
"[",
"x",
"[",
"1",
"]",
"for",
"x",
"in",
"splits",
"]",
"nfold",
"=",
"len",
"(",
"out_idset",
")",
"ret",
"=",
"[",
"]",
"for",
"k",
"in",
"range",
"(",
"nfold",
")",
":",
"dtrain",
"=",
"dall",
".",
"slice",
"(",
"in_idset",
"[",
"k",
"]",
")",
"dtest",
"=",
"dall",
".",
"slice",
"(",
"out_idset",
"[",
"k",
"]",
")",
"# run preprocessing on the data set if needed",
"if",
"fpreproc",
"is",
"not",
"None",
":",
"dtrain",
",",
"dtest",
",",
"tparam",
"=",
"fpreproc",
"(",
"dtrain",
",",
"dtest",
",",
"param",
".",
"copy",
"(",
")",
")",
"else",
":",
"tparam",
"=",
"param",
"plst",
"=",
"list",
"(",
"tparam",
".",
"items",
"(",
")",
")",
"+",
"[",
"(",
"'eval_metric'",
",",
"itm",
")",
"for",
"itm",
"in",
"evals",
"]",
"ret",
".",
"append",
"(",
"CVPack",
"(",
"dtrain",
",",
"dtest",
",",
"plst",
")",
")",
"return",
"ret"
] |
Make an n-fold list of CVPack from random indices.
|
[
"Make",
"an",
"n",
"-",
"fold",
"list",
"of",
"CVPack",
"from",
"random",
"indices",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/training.py#L237-L286
|
train
|
dmlc/xgboost
|
python-package/xgboost/training.py
|
aggcv
|
def aggcv(rlist):
# pylint: disable=invalid-name
"""
Aggregate cross-validation results.
If verbose_eval is true, progress is displayed in every call. If
verbose_eval is an integer, progress will only be displayed every
`verbose_eval` trees, tracked via trial.
"""
cvmap = {}
idx = rlist[0].split()[0]
for line in rlist:
arr = line.split()
assert idx == arr[0]
for it in arr[1:]:
if not isinstance(it, STRING_TYPES):
it = it.decode()
k, v = it.split(':')
if k not in cvmap:
cvmap[k] = []
cvmap[k].append(float(v))
msg = idx
results = []
for k, v in sorted(cvmap.items(), key=lambda x: (x[0].startswith('test'), x[0])):
v = np.array(v)
if not isinstance(msg, STRING_TYPES):
msg = msg.decode()
mean, std = np.mean(v), np.std(v)
results.extend([(k, mean, std)])
return results
|
python
|
def aggcv(rlist):
# pylint: disable=invalid-name
"""
Aggregate cross-validation results.
If verbose_eval is true, progress is displayed in every call. If
verbose_eval is an integer, progress will only be displayed every
`verbose_eval` trees, tracked via trial.
"""
cvmap = {}
idx = rlist[0].split()[0]
for line in rlist:
arr = line.split()
assert idx == arr[0]
for it in arr[1:]:
if not isinstance(it, STRING_TYPES):
it = it.decode()
k, v = it.split(':')
if k not in cvmap:
cvmap[k] = []
cvmap[k].append(float(v))
msg = idx
results = []
for k, v in sorted(cvmap.items(), key=lambda x: (x[0].startswith('test'), x[0])):
v = np.array(v)
if not isinstance(msg, STRING_TYPES):
msg = msg.decode()
mean, std = np.mean(v), np.std(v)
results.extend([(k, mean, std)])
return results
|
[
"def",
"aggcv",
"(",
"rlist",
")",
":",
"# pylint: disable=invalid-name",
"cvmap",
"=",
"{",
"}",
"idx",
"=",
"rlist",
"[",
"0",
"]",
".",
"split",
"(",
")",
"[",
"0",
"]",
"for",
"line",
"in",
"rlist",
":",
"arr",
"=",
"line",
".",
"split",
"(",
")",
"assert",
"idx",
"==",
"arr",
"[",
"0",
"]",
"for",
"it",
"in",
"arr",
"[",
"1",
":",
"]",
":",
"if",
"not",
"isinstance",
"(",
"it",
",",
"STRING_TYPES",
")",
":",
"it",
"=",
"it",
".",
"decode",
"(",
")",
"k",
",",
"v",
"=",
"it",
".",
"split",
"(",
"':'",
")",
"if",
"k",
"not",
"in",
"cvmap",
":",
"cvmap",
"[",
"k",
"]",
"=",
"[",
"]",
"cvmap",
"[",
"k",
"]",
".",
"append",
"(",
"float",
"(",
"v",
")",
")",
"msg",
"=",
"idx",
"results",
"=",
"[",
"]",
"for",
"k",
",",
"v",
"in",
"sorted",
"(",
"cvmap",
".",
"items",
"(",
")",
",",
"key",
"=",
"lambda",
"x",
":",
"(",
"x",
"[",
"0",
"]",
".",
"startswith",
"(",
"'test'",
")",
",",
"x",
"[",
"0",
"]",
")",
")",
":",
"v",
"=",
"np",
".",
"array",
"(",
"v",
")",
"if",
"not",
"isinstance",
"(",
"msg",
",",
"STRING_TYPES",
")",
":",
"msg",
"=",
"msg",
".",
"decode",
"(",
")",
"mean",
",",
"std",
"=",
"np",
".",
"mean",
"(",
"v",
")",
",",
"np",
".",
"std",
"(",
"v",
")",
"results",
".",
"extend",
"(",
"[",
"(",
"k",
",",
"mean",
",",
"std",
")",
"]",
")",
"return",
"results"
] |
Aggregate cross-validation results.
If verbose_eval is true, progress is displayed in every call. If
verbose_eval is an integer, progress will only be displayed every
`verbose_eval` trees, tracked via trial.
|
[
"Aggregate",
"cross",
"-",
"validation",
"results",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/training.py#L289-L318
|
train
|
dmlc/xgboost
|
python-package/xgboost/training.py
|
cv
|
def cv(params, dtrain, num_boost_round=10, nfold=3, stratified=False, folds=None,
metrics=(), obj=None, feval=None, maximize=False, early_stopping_rounds=None,
fpreproc=None, as_pandas=True, verbose_eval=None, show_stdv=True,
seed=0, callbacks=None, shuffle=True):
# pylint: disable = invalid-name
"""Cross-validation with given parameters.
Parameters
----------
params : dict
Booster params.
dtrain : DMatrix
Data to be trained.
num_boost_round : int
Number of boosting iterations.
nfold : int
Number of folds in CV.
stratified : bool
Perform stratified sampling.
folds : a KFold or StratifiedKFold instance or list of fold indices
Sklearn KFolds or StratifiedKFolds object.
Alternatively may explicitly pass sample indices for each fold.
For ``n`` folds, **folds** should be a length ``n`` list of tuples.
Each tuple is ``(in,out)`` where ``in`` is a list of indices to be used
as the training samples for the ``n`` th fold and ``out`` is a list of
indices to be used as the testing samples for the ``n`` th fold.
metrics : string or list of strings
Evaluation metrics to be watched in CV.
obj : function
Custom objective function.
feval : function
Custom evaluation function.
maximize : bool
Whether to maximize feval.
early_stopping_rounds: int
Activates early stopping. CV error needs to decrease at least
every <early_stopping_rounds> round(s) to continue.
Last entry in evaluation history is the one from best iteration.
fpreproc : function
Preprocessing function that takes (dtrain, dtest, param) and returns
transformed versions of those.
as_pandas : bool, default True
Return pd.DataFrame when pandas is installed.
If False or pandas is not installed, return np.ndarray
verbose_eval : bool, int, or None, default None
Whether to display the progress. If None, progress will be displayed
when np.ndarray is returned. If True, progress will be displayed at
boosting stage. If an integer is given, progress will be displayed
at every given `verbose_eval` boosting stage.
show_stdv : bool, default True
Whether to display the standard deviation in progress.
Results are not affected, and always contains std.
seed : int
Seed used to generate the folds (passed to numpy.random.seed).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using
:ref:`Callback API <callback_api>`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
shuffle : bool
Shuffle data before creating folds.
Returns
-------
evaluation history : list(string)
"""
if stratified is True and not SKLEARN_INSTALLED:
raise XGBoostError('sklearn needs to be installed in order to use stratified cv')
if isinstance(metrics, str):
metrics = [metrics]
if isinstance(params, list):
_metrics = [x[1] for x in params if x[0] == 'eval_metric']
params = dict(params)
if 'eval_metric' in params:
params['eval_metric'] = _metrics
else:
params = dict((k, v) for k, v in params.items())
if (not metrics) and 'eval_metric' in params:
if isinstance(params['eval_metric'], list):
metrics = params['eval_metric']
else:
metrics = [params['eval_metric']]
params.pop("eval_metric", None)
results = {}
cvfolds = mknfold(dtrain, nfold, params, seed, metrics, fpreproc,
stratified, folds, shuffle)
# setup callbacks
callbacks = [] if callbacks is None else callbacks
if early_stopping_rounds is not None:
callbacks.append(callback.early_stop(early_stopping_rounds,
maximize=maximize,
verbose=False))
if isinstance(verbose_eval, bool) and verbose_eval:
callbacks.append(callback.print_evaluation(show_stdv=show_stdv))
else:
if isinstance(verbose_eval, int):
callbacks.append(callback.print_evaluation(verbose_eval, show_stdv=show_stdv))
callbacks_before_iter = [
cb for cb in callbacks if cb.__dict__.get('before_iteration', False)]
callbacks_after_iter = [
cb for cb in callbacks if not cb.__dict__.get('before_iteration', False)]
for i in range(num_boost_round):
for cb in callbacks_before_iter:
cb(CallbackEnv(model=None,
cvfolds=cvfolds,
iteration=i,
begin_iteration=0,
end_iteration=num_boost_round,
rank=0,
evaluation_result_list=None))
for fold in cvfolds:
fold.update(i, obj)
res = aggcv([f.eval(i, feval) for f in cvfolds])
for key, mean, std in res:
if key + '-mean' not in results:
results[key + '-mean'] = []
if key + '-std' not in results:
results[key + '-std'] = []
results[key + '-mean'].append(mean)
results[key + '-std'].append(std)
try:
for cb in callbacks_after_iter:
cb(CallbackEnv(model=None,
cvfolds=cvfolds,
iteration=i,
begin_iteration=0,
end_iteration=num_boost_round,
rank=0,
evaluation_result_list=res))
except EarlyStopException as e:
for k in results:
results[k] = results[k][:(e.best_iteration + 1)]
break
if as_pandas:
try:
import pandas as pd
results = pd.DataFrame.from_dict(results)
except ImportError:
pass
return results
|
python
|
def cv(params, dtrain, num_boost_round=10, nfold=3, stratified=False, folds=None,
metrics=(), obj=None, feval=None, maximize=False, early_stopping_rounds=None,
fpreproc=None, as_pandas=True, verbose_eval=None, show_stdv=True,
seed=0, callbacks=None, shuffle=True):
# pylint: disable = invalid-name
"""Cross-validation with given parameters.
Parameters
----------
params : dict
Booster params.
dtrain : DMatrix
Data to be trained.
num_boost_round : int
Number of boosting iterations.
nfold : int
Number of folds in CV.
stratified : bool
Perform stratified sampling.
folds : a KFold or StratifiedKFold instance or list of fold indices
Sklearn KFolds or StratifiedKFolds object.
Alternatively may explicitly pass sample indices for each fold.
For ``n`` folds, **folds** should be a length ``n`` list of tuples.
Each tuple is ``(in,out)`` where ``in`` is a list of indices to be used
as the training samples for the ``n`` th fold and ``out`` is a list of
indices to be used as the testing samples for the ``n`` th fold.
metrics : string or list of strings
Evaluation metrics to be watched in CV.
obj : function
Custom objective function.
feval : function
Custom evaluation function.
maximize : bool
Whether to maximize feval.
early_stopping_rounds: int
Activates early stopping. CV error needs to decrease at least
every <early_stopping_rounds> round(s) to continue.
Last entry in evaluation history is the one from best iteration.
fpreproc : function
Preprocessing function that takes (dtrain, dtest, param) and returns
transformed versions of those.
as_pandas : bool, default True
Return pd.DataFrame when pandas is installed.
If False or pandas is not installed, return np.ndarray
verbose_eval : bool, int, or None, default None
Whether to display the progress. If None, progress will be displayed
when np.ndarray is returned. If True, progress will be displayed at
boosting stage. If an integer is given, progress will be displayed
at every given `verbose_eval` boosting stage.
show_stdv : bool, default True
Whether to display the standard deviation in progress.
Results are not affected, and always contains std.
seed : int
Seed used to generate the folds (passed to numpy.random.seed).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using
:ref:`Callback API <callback_api>`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
shuffle : bool
Shuffle data before creating folds.
Returns
-------
evaluation history : list(string)
"""
if stratified is True and not SKLEARN_INSTALLED:
raise XGBoostError('sklearn needs to be installed in order to use stratified cv')
if isinstance(metrics, str):
metrics = [metrics]
if isinstance(params, list):
_metrics = [x[1] for x in params if x[0] == 'eval_metric']
params = dict(params)
if 'eval_metric' in params:
params['eval_metric'] = _metrics
else:
params = dict((k, v) for k, v in params.items())
if (not metrics) and 'eval_metric' in params:
if isinstance(params['eval_metric'], list):
metrics = params['eval_metric']
else:
metrics = [params['eval_metric']]
params.pop("eval_metric", None)
results = {}
cvfolds = mknfold(dtrain, nfold, params, seed, metrics, fpreproc,
stratified, folds, shuffle)
# setup callbacks
callbacks = [] if callbacks is None else callbacks
if early_stopping_rounds is not None:
callbacks.append(callback.early_stop(early_stopping_rounds,
maximize=maximize,
verbose=False))
if isinstance(verbose_eval, bool) and verbose_eval:
callbacks.append(callback.print_evaluation(show_stdv=show_stdv))
else:
if isinstance(verbose_eval, int):
callbacks.append(callback.print_evaluation(verbose_eval, show_stdv=show_stdv))
callbacks_before_iter = [
cb for cb in callbacks if cb.__dict__.get('before_iteration', False)]
callbacks_after_iter = [
cb for cb in callbacks if not cb.__dict__.get('before_iteration', False)]
for i in range(num_boost_round):
for cb in callbacks_before_iter:
cb(CallbackEnv(model=None,
cvfolds=cvfolds,
iteration=i,
begin_iteration=0,
end_iteration=num_boost_round,
rank=0,
evaluation_result_list=None))
for fold in cvfolds:
fold.update(i, obj)
res = aggcv([f.eval(i, feval) for f in cvfolds])
for key, mean, std in res:
if key + '-mean' not in results:
results[key + '-mean'] = []
if key + '-std' not in results:
results[key + '-std'] = []
results[key + '-mean'].append(mean)
results[key + '-std'].append(std)
try:
for cb in callbacks_after_iter:
cb(CallbackEnv(model=None,
cvfolds=cvfolds,
iteration=i,
begin_iteration=0,
end_iteration=num_boost_round,
rank=0,
evaluation_result_list=res))
except EarlyStopException as e:
for k in results:
results[k] = results[k][:(e.best_iteration + 1)]
break
if as_pandas:
try:
import pandas as pd
results = pd.DataFrame.from_dict(results)
except ImportError:
pass
return results
|
[
"def",
"cv",
"(",
"params",
",",
"dtrain",
",",
"num_boost_round",
"=",
"10",
",",
"nfold",
"=",
"3",
",",
"stratified",
"=",
"False",
",",
"folds",
"=",
"None",
",",
"metrics",
"=",
"(",
")",
",",
"obj",
"=",
"None",
",",
"feval",
"=",
"None",
",",
"maximize",
"=",
"False",
",",
"early_stopping_rounds",
"=",
"None",
",",
"fpreproc",
"=",
"None",
",",
"as_pandas",
"=",
"True",
",",
"verbose_eval",
"=",
"None",
",",
"show_stdv",
"=",
"True",
",",
"seed",
"=",
"0",
",",
"callbacks",
"=",
"None",
",",
"shuffle",
"=",
"True",
")",
":",
"# pylint: disable = invalid-name",
"if",
"stratified",
"is",
"True",
"and",
"not",
"SKLEARN_INSTALLED",
":",
"raise",
"XGBoostError",
"(",
"'sklearn needs to be installed in order to use stratified cv'",
")",
"if",
"isinstance",
"(",
"metrics",
",",
"str",
")",
":",
"metrics",
"=",
"[",
"metrics",
"]",
"if",
"isinstance",
"(",
"params",
",",
"list",
")",
":",
"_metrics",
"=",
"[",
"x",
"[",
"1",
"]",
"for",
"x",
"in",
"params",
"if",
"x",
"[",
"0",
"]",
"==",
"'eval_metric'",
"]",
"params",
"=",
"dict",
"(",
"params",
")",
"if",
"'eval_metric'",
"in",
"params",
":",
"params",
"[",
"'eval_metric'",
"]",
"=",
"_metrics",
"else",
":",
"params",
"=",
"dict",
"(",
"(",
"k",
",",
"v",
")",
"for",
"k",
",",
"v",
"in",
"params",
".",
"items",
"(",
")",
")",
"if",
"(",
"not",
"metrics",
")",
"and",
"'eval_metric'",
"in",
"params",
":",
"if",
"isinstance",
"(",
"params",
"[",
"'eval_metric'",
"]",
",",
"list",
")",
":",
"metrics",
"=",
"params",
"[",
"'eval_metric'",
"]",
"else",
":",
"metrics",
"=",
"[",
"params",
"[",
"'eval_metric'",
"]",
"]",
"params",
".",
"pop",
"(",
"\"eval_metric\"",
",",
"None",
")",
"results",
"=",
"{",
"}",
"cvfolds",
"=",
"mknfold",
"(",
"dtrain",
",",
"nfold",
",",
"params",
",",
"seed",
",",
"metrics",
",",
"fpreproc",
",",
"stratified",
",",
"folds",
",",
"shuffle",
")",
"# setup callbacks",
"callbacks",
"=",
"[",
"]",
"if",
"callbacks",
"is",
"None",
"else",
"callbacks",
"if",
"early_stopping_rounds",
"is",
"not",
"None",
":",
"callbacks",
".",
"append",
"(",
"callback",
".",
"early_stop",
"(",
"early_stopping_rounds",
",",
"maximize",
"=",
"maximize",
",",
"verbose",
"=",
"False",
")",
")",
"if",
"isinstance",
"(",
"verbose_eval",
",",
"bool",
")",
"and",
"verbose_eval",
":",
"callbacks",
".",
"append",
"(",
"callback",
".",
"print_evaluation",
"(",
"show_stdv",
"=",
"show_stdv",
")",
")",
"else",
":",
"if",
"isinstance",
"(",
"verbose_eval",
",",
"int",
")",
":",
"callbacks",
".",
"append",
"(",
"callback",
".",
"print_evaluation",
"(",
"verbose_eval",
",",
"show_stdv",
"=",
"show_stdv",
")",
")",
"callbacks_before_iter",
"=",
"[",
"cb",
"for",
"cb",
"in",
"callbacks",
"if",
"cb",
".",
"__dict__",
".",
"get",
"(",
"'before_iteration'",
",",
"False",
")",
"]",
"callbacks_after_iter",
"=",
"[",
"cb",
"for",
"cb",
"in",
"callbacks",
"if",
"not",
"cb",
".",
"__dict__",
".",
"get",
"(",
"'before_iteration'",
",",
"False",
")",
"]",
"for",
"i",
"in",
"range",
"(",
"num_boost_round",
")",
":",
"for",
"cb",
"in",
"callbacks_before_iter",
":",
"cb",
"(",
"CallbackEnv",
"(",
"model",
"=",
"None",
",",
"cvfolds",
"=",
"cvfolds",
",",
"iteration",
"=",
"i",
",",
"begin_iteration",
"=",
"0",
",",
"end_iteration",
"=",
"num_boost_round",
",",
"rank",
"=",
"0",
",",
"evaluation_result_list",
"=",
"None",
")",
")",
"for",
"fold",
"in",
"cvfolds",
":",
"fold",
".",
"update",
"(",
"i",
",",
"obj",
")",
"res",
"=",
"aggcv",
"(",
"[",
"f",
".",
"eval",
"(",
"i",
",",
"feval",
")",
"for",
"f",
"in",
"cvfolds",
"]",
")",
"for",
"key",
",",
"mean",
",",
"std",
"in",
"res",
":",
"if",
"key",
"+",
"'-mean'",
"not",
"in",
"results",
":",
"results",
"[",
"key",
"+",
"'-mean'",
"]",
"=",
"[",
"]",
"if",
"key",
"+",
"'-std'",
"not",
"in",
"results",
":",
"results",
"[",
"key",
"+",
"'-std'",
"]",
"=",
"[",
"]",
"results",
"[",
"key",
"+",
"'-mean'",
"]",
".",
"append",
"(",
"mean",
")",
"results",
"[",
"key",
"+",
"'-std'",
"]",
".",
"append",
"(",
"std",
")",
"try",
":",
"for",
"cb",
"in",
"callbacks_after_iter",
":",
"cb",
"(",
"CallbackEnv",
"(",
"model",
"=",
"None",
",",
"cvfolds",
"=",
"cvfolds",
",",
"iteration",
"=",
"i",
",",
"begin_iteration",
"=",
"0",
",",
"end_iteration",
"=",
"num_boost_round",
",",
"rank",
"=",
"0",
",",
"evaluation_result_list",
"=",
"res",
")",
")",
"except",
"EarlyStopException",
"as",
"e",
":",
"for",
"k",
"in",
"results",
":",
"results",
"[",
"k",
"]",
"=",
"results",
"[",
"k",
"]",
"[",
":",
"(",
"e",
".",
"best_iteration",
"+",
"1",
")",
"]",
"break",
"if",
"as_pandas",
":",
"try",
":",
"import",
"pandas",
"as",
"pd",
"results",
"=",
"pd",
".",
"DataFrame",
".",
"from_dict",
"(",
"results",
")",
"except",
"ImportError",
":",
"pass",
"return",
"results"
] |
Cross-validation with given parameters.
Parameters
----------
params : dict
Booster params.
dtrain : DMatrix
Data to be trained.
num_boost_round : int
Number of boosting iterations.
nfold : int
Number of folds in CV.
stratified : bool
Perform stratified sampling.
folds : a KFold or StratifiedKFold instance or list of fold indices
Sklearn KFolds or StratifiedKFolds object.
Alternatively may explicitly pass sample indices for each fold.
For ``n`` folds, **folds** should be a length ``n`` list of tuples.
Each tuple is ``(in,out)`` where ``in`` is a list of indices to be used
as the training samples for the ``n`` th fold and ``out`` is a list of
indices to be used as the testing samples for the ``n`` th fold.
metrics : string or list of strings
Evaluation metrics to be watched in CV.
obj : function
Custom objective function.
feval : function
Custom evaluation function.
maximize : bool
Whether to maximize feval.
early_stopping_rounds: int
Activates early stopping. CV error needs to decrease at least
every <early_stopping_rounds> round(s) to continue.
Last entry in evaluation history is the one from best iteration.
fpreproc : function
Preprocessing function that takes (dtrain, dtest, param) and returns
transformed versions of those.
as_pandas : bool, default True
Return pd.DataFrame when pandas is installed.
If False or pandas is not installed, return np.ndarray
verbose_eval : bool, int, or None, default None
Whether to display the progress. If None, progress will be displayed
when np.ndarray is returned. If True, progress will be displayed at
boosting stage. If an integer is given, progress will be displayed
at every given `verbose_eval` boosting stage.
show_stdv : bool, default True
Whether to display the standard deviation in progress.
Results are not affected, and always contains std.
seed : int
Seed used to generate the folds (passed to numpy.random.seed).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using
:ref:`Callback API <callback_api>`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
shuffle : bool
Shuffle data before creating folds.
Returns
-------
evaluation history : list(string)
|
[
"Cross",
"-",
"validation",
"with",
"given",
"parameters",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/training.py#L321-L474
|
train
|
dmlc/xgboost
|
python-package/xgboost/training.py
|
CVPack.update
|
def update(self, iteration, fobj):
""""Update the boosters for one iteration"""
self.bst.update(self.dtrain, iteration, fobj)
|
python
|
def update(self, iteration, fobj):
""""Update the boosters for one iteration"""
self.bst.update(self.dtrain, iteration, fobj)
|
[
"def",
"update",
"(",
"self",
",",
"iteration",
",",
"fobj",
")",
":",
"self",
".",
"bst",
".",
"update",
"(",
"self",
".",
"dtrain",
",",
"iteration",
",",
"fobj",
")"
] |
Update the boosters for one iteration
|
[
"Update",
"the",
"boosters",
"for",
"one",
"iteration"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/training.py#L228-L230
|
train
|
dmlc/xgboost
|
python-package/xgboost/training.py
|
CVPack.eval
|
def eval(self, iteration, feval):
""""Evaluate the CVPack for one iteration."""
return self.bst.eval_set(self.watchlist, iteration, feval)
|
python
|
def eval(self, iteration, feval):
""""Evaluate the CVPack for one iteration."""
return self.bst.eval_set(self.watchlist, iteration, feval)
|
[
"def",
"eval",
"(",
"self",
",",
"iteration",
",",
"feval",
")",
":",
"return",
"self",
".",
"bst",
".",
"eval_set",
"(",
"self",
".",
"watchlist",
",",
"iteration",
",",
"feval",
")"
] |
Evaluate the CVPack for one iteration.
|
[
"Evaluate",
"the",
"CVPack",
"for",
"one",
"iteration",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/training.py#L232-L234
|
train
|
dmlc/xgboost
|
python-package/xgboost/callback.py
|
_get_callback_context
|
def _get_callback_context(env):
"""return whether the current callback context is cv or train"""
if env.model is not None and env.cvfolds is None:
context = 'train'
elif env.model is None and env.cvfolds is not None:
context = 'cv'
return context
|
python
|
def _get_callback_context(env):
"""return whether the current callback context is cv or train"""
if env.model is not None and env.cvfolds is None:
context = 'train'
elif env.model is None and env.cvfolds is not None:
context = 'cv'
return context
|
[
"def",
"_get_callback_context",
"(",
"env",
")",
":",
"if",
"env",
".",
"model",
"is",
"not",
"None",
"and",
"env",
".",
"cvfolds",
"is",
"None",
":",
"context",
"=",
"'train'",
"elif",
"env",
".",
"model",
"is",
"None",
"and",
"env",
".",
"cvfolds",
"is",
"not",
"None",
":",
"context",
"=",
"'cv'",
"return",
"context"
] |
return whether the current callback context is cv or train
|
[
"return",
"whether",
"the",
"current",
"callback",
"context",
"is",
"cv",
"or",
"train"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/callback.py#L10-L16
|
train
|
dmlc/xgboost
|
python-package/xgboost/callback.py
|
_fmt_metric
|
def _fmt_metric(value, show_stdv=True):
"""format metric string"""
if len(value) == 2:
return '%s:%g' % (value[0], value[1])
if len(value) == 3:
if show_stdv:
return '%s:%g+%g' % (value[0], value[1], value[2])
return '%s:%g' % (value[0], value[1])
raise ValueError("wrong metric value")
|
python
|
def _fmt_metric(value, show_stdv=True):
"""format metric string"""
if len(value) == 2:
return '%s:%g' % (value[0], value[1])
if len(value) == 3:
if show_stdv:
return '%s:%g+%g' % (value[0], value[1], value[2])
return '%s:%g' % (value[0], value[1])
raise ValueError("wrong metric value")
|
[
"def",
"_fmt_metric",
"(",
"value",
",",
"show_stdv",
"=",
"True",
")",
":",
"if",
"len",
"(",
"value",
")",
"==",
"2",
":",
"return",
"'%s:%g'",
"%",
"(",
"value",
"[",
"0",
"]",
",",
"value",
"[",
"1",
"]",
")",
"if",
"len",
"(",
"value",
")",
"==",
"3",
":",
"if",
"show_stdv",
":",
"return",
"'%s:%g+%g'",
"%",
"(",
"value",
"[",
"0",
"]",
",",
"value",
"[",
"1",
"]",
",",
"value",
"[",
"2",
"]",
")",
"return",
"'%s:%g'",
"%",
"(",
"value",
"[",
"0",
"]",
",",
"value",
"[",
"1",
"]",
")",
"raise",
"ValueError",
"(",
"\"wrong metric value\"",
")"
] |
format metric string
|
[
"format",
"metric",
"string"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/callback.py#L19-L27
|
train
|
dmlc/xgboost
|
python-package/xgboost/callback.py
|
print_evaluation
|
def print_evaluation(period=1, show_stdv=True):
"""Create a callback that print evaluation result.
We print the evaluation results every **period** iterations
and on the first and the last iterations.
Parameters
----------
period : int
The period to log the evaluation results
show_stdv : bool, optional
Whether show stdv if provided
Returns
-------
callback : function
A callback that print evaluation every period iterations.
"""
def callback(env):
"""internal function"""
if env.rank != 0 or (not env.evaluation_result_list) or period is False or period == 0:
return
i = env.iteration
if i % period == 0 or i + 1 == env.begin_iteration or i + 1 == env.end_iteration:
msg = '\t'.join([_fmt_metric(x, show_stdv) for x in env.evaluation_result_list])
rabit.tracker_print('[%d]\t%s\n' % (i, msg))
return callback
|
python
|
def print_evaluation(period=1, show_stdv=True):
"""Create a callback that print evaluation result.
We print the evaluation results every **period** iterations
and on the first and the last iterations.
Parameters
----------
period : int
The period to log the evaluation results
show_stdv : bool, optional
Whether show stdv if provided
Returns
-------
callback : function
A callback that print evaluation every period iterations.
"""
def callback(env):
"""internal function"""
if env.rank != 0 or (not env.evaluation_result_list) or period is False or period == 0:
return
i = env.iteration
if i % period == 0 or i + 1 == env.begin_iteration or i + 1 == env.end_iteration:
msg = '\t'.join([_fmt_metric(x, show_stdv) for x in env.evaluation_result_list])
rabit.tracker_print('[%d]\t%s\n' % (i, msg))
return callback
|
[
"def",
"print_evaluation",
"(",
"period",
"=",
"1",
",",
"show_stdv",
"=",
"True",
")",
":",
"def",
"callback",
"(",
"env",
")",
":",
"\"\"\"internal function\"\"\"",
"if",
"env",
".",
"rank",
"!=",
"0",
"or",
"(",
"not",
"env",
".",
"evaluation_result_list",
")",
"or",
"period",
"is",
"False",
"or",
"period",
"==",
"0",
":",
"return",
"i",
"=",
"env",
".",
"iteration",
"if",
"i",
"%",
"period",
"==",
"0",
"or",
"i",
"+",
"1",
"==",
"env",
".",
"begin_iteration",
"or",
"i",
"+",
"1",
"==",
"env",
".",
"end_iteration",
":",
"msg",
"=",
"'\\t'",
".",
"join",
"(",
"[",
"_fmt_metric",
"(",
"x",
",",
"show_stdv",
")",
"for",
"x",
"in",
"env",
".",
"evaluation_result_list",
"]",
")",
"rabit",
".",
"tracker_print",
"(",
"'[%d]\\t%s\\n'",
"%",
"(",
"i",
",",
"msg",
")",
")",
"return",
"callback"
] |
Create a callback that print evaluation result.
We print the evaluation results every **period** iterations
and on the first and the last iterations.
Parameters
----------
period : int
The period to log the evaluation results
show_stdv : bool, optional
Whether show stdv if provided
Returns
-------
callback : function
A callback that print evaluation every period iterations.
|
[
"Create",
"a",
"callback",
"that",
"print",
"evaluation",
"result",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/callback.py#L30-L57
|
train
|
dmlc/xgboost
|
python-package/xgboost/callback.py
|
record_evaluation
|
def record_evaluation(eval_result):
"""Create a call back that records the evaluation history into **eval_result**.
Parameters
----------
eval_result : dict
A dictionary to store the evaluation results.
Returns
-------
callback : function
The requested callback function.
"""
if not isinstance(eval_result, dict):
raise TypeError('eval_result has to be a dictionary')
eval_result.clear()
def init(env):
"""internal function"""
for k, _ in env.evaluation_result_list:
pos = k.index('-')
key = k[:pos]
metric = k[pos + 1:]
if key not in eval_result:
eval_result[key] = {}
if metric not in eval_result[key]:
eval_result[key][metric] = []
def callback(env):
"""internal function"""
if not eval_result:
init(env)
for k, v in env.evaluation_result_list:
pos = k.index('-')
key = k[:pos]
metric = k[pos + 1:]
eval_result[key][metric].append(v)
return callback
|
python
|
def record_evaluation(eval_result):
"""Create a call back that records the evaluation history into **eval_result**.
Parameters
----------
eval_result : dict
A dictionary to store the evaluation results.
Returns
-------
callback : function
The requested callback function.
"""
if not isinstance(eval_result, dict):
raise TypeError('eval_result has to be a dictionary')
eval_result.clear()
def init(env):
"""internal function"""
for k, _ in env.evaluation_result_list:
pos = k.index('-')
key = k[:pos]
metric = k[pos + 1:]
if key not in eval_result:
eval_result[key] = {}
if metric not in eval_result[key]:
eval_result[key][metric] = []
def callback(env):
"""internal function"""
if not eval_result:
init(env)
for k, v in env.evaluation_result_list:
pos = k.index('-')
key = k[:pos]
metric = k[pos + 1:]
eval_result[key][metric].append(v)
return callback
|
[
"def",
"record_evaluation",
"(",
"eval_result",
")",
":",
"if",
"not",
"isinstance",
"(",
"eval_result",
",",
"dict",
")",
":",
"raise",
"TypeError",
"(",
"'eval_result has to be a dictionary'",
")",
"eval_result",
".",
"clear",
"(",
")",
"def",
"init",
"(",
"env",
")",
":",
"\"\"\"internal function\"\"\"",
"for",
"k",
",",
"_",
"in",
"env",
".",
"evaluation_result_list",
":",
"pos",
"=",
"k",
".",
"index",
"(",
"'-'",
")",
"key",
"=",
"k",
"[",
":",
"pos",
"]",
"metric",
"=",
"k",
"[",
"pos",
"+",
"1",
":",
"]",
"if",
"key",
"not",
"in",
"eval_result",
":",
"eval_result",
"[",
"key",
"]",
"=",
"{",
"}",
"if",
"metric",
"not",
"in",
"eval_result",
"[",
"key",
"]",
":",
"eval_result",
"[",
"key",
"]",
"[",
"metric",
"]",
"=",
"[",
"]",
"def",
"callback",
"(",
"env",
")",
":",
"\"\"\"internal function\"\"\"",
"if",
"not",
"eval_result",
":",
"init",
"(",
"env",
")",
"for",
"k",
",",
"v",
"in",
"env",
".",
"evaluation_result_list",
":",
"pos",
"=",
"k",
".",
"index",
"(",
"'-'",
")",
"key",
"=",
"k",
"[",
":",
"pos",
"]",
"metric",
"=",
"k",
"[",
"pos",
"+",
"1",
":",
"]",
"eval_result",
"[",
"key",
"]",
"[",
"metric",
"]",
".",
"append",
"(",
"v",
")",
"return",
"callback"
] |
Create a call back that records the evaluation history into **eval_result**.
Parameters
----------
eval_result : dict
A dictionary to store the evaluation results.
Returns
-------
callback : function
The requested callback function.
|
[
"Create",
"a",
"call",
"back",
"that",
"records",
"the",
"evaluation",
"history",
"into",
"**",
"eval_result",
"**",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/callback.py#L60-L97
|
train
|
dmlc/xgboost
|
python-package/xgboost/callback.py
|
reset_learning_rate
|
def reset_learning_rate(learning_rates):
"""Reset learning rate after iteration 1
NOTE: the initial learning rate will still take in-effect on first iteration.
Parameters
----------
learning_rates: list or function
List of learning rate for each boosting round
or a customized function that calculates eta in terms of
current number of round and the total number of boosting round (e.g.
yields learning rate decay)
* list ``l``: ``eta = l[boosting_round]``
* function ``f``: ``eta = f(boosting_round, num_boost_round)``
Returns
-------
callback : function
The requested callback function.
"""
def get_learning_rate(i, n, learning_rates):
"""helper providing the learning rate"""
if isinstance(learning_rates, list):
if len(learning_rates) != n:
raise ValueError("Length of list 'learning_rates' has to equal 'num_boost_round'.")
new_learning_rate = learning_rates[i]
else:
new_learning_rate = learning_rates(i, n)
return new_learning_rate
def callback(env):
"""internal function"""
context = _get_callback_context(env)
if context == 'train':
bst, i, n = env.model, env.iteration, env.end_iteration
bst.set_param('learning_rate', get_learning_rate(i, n, learning_rates))
elif context == 'cv':
i, n = env.iteration, env.end_iteration
for cvpack in env.cvfolds:
bst = cvpack.bst
bst.set_param('learning_rate', get_learning_rate(i, n, learning_rates))
callback.before_iteration = True
return callback
|
python
|
def reset_learning_rate(learning_rates):
"""Reset learning rate after iteration 1
NOTE: the initial learning rate will still take in-effect on first iteration.
Parameters
----------
learning_rates: list or function
List of learning rate for each boosting round
or a customized function that calculates eta in terms of
current number of round and the total number of boosting round (e.g.
yields learning rate decay)
* list ``l``: ``eta = l[boosting_round]``
* function ``f``: ``eta = f(boosting_round, num_boost_round)``
Returns
-------
callback : function
The requested callback function.
"""
def get_learning_rate(i, n, learning_rates):
"""helper providing the learning rate"""
if isinstance(learning_rates, list):
if len(learning_rates) != n:
raise ValueError("Length of list 'learning_rates' has to equal 'num_boost_round'.")
new_learning_rate = learning_rates[i]
else:
new_learning_rate = learning_rates(i, n)
return new_learning_rate
def callback(env):
"""internal function"""
context = _get_callback_context(env)
if context == 'train':
bst, i, n = env.model, env.iteration, env.end_iteration
bst.set_param('learning_rate', get_learning_rate(i, n, learning_rates))
elif context == 'cv':
i, n = env.iteration, env.end_iteration
for cvpack in env.cvfolds:
bst = cvpack.bst
bst.set_param('learning_rate', get_learning_rate(i, n, learning_rates))
callback.before_iteration = True
return callback
|
[
"def",
"reset_learning_rate",
"(",
"learning_rates",
")",
":",
"def",
"get_learning_rate",
"(",
"i",
",",
"n",
",",
"learning_rates",
")",
":",
"\"\"\"helper providing the learning rate\"\"\"",
"if",
"isinstance",
"(",
"learning_rates",
",",
"list",
")",
":",
"if",
"len",
"(",
"learning_rates",
")",
"!=",
"n",
":",
"raise",
"ValueError",
"(",
"\"Length of list 'learning_rates' has to equal 'num_boost_round'.\"",
")",
"new_learning_rate",
"=",
"learning_rates",
"[",
"i",
"]",
"else",
":",
"new_learning_rate",
"=",
"learning_rates",
"(",
"i",
",",
"n",
")",
"return",
"new_learning_rate",
"def",
"callback",
"(",
"env",
")",
":",
"\"\"\"internal function\"\"\"",
"context",
"=",
"_get_callback_context",
"(",
"env",
")",
"if",
"context",
"==",
"'train'",
":",
"bst",
",",
"i",
",",
"n",
"=",
"env",
".",
"model",
",",
"env",
".",
"iteration",
",",
"env",
".",
"end_iteration",
"bst",
".",
"set_param",
"(",
"'learning_rate'",
",",
"get_learning_rate",
"(",
"i",
",",
"n",
",",
"learning_rates",
")",
")",
"elif",
"context",
"==",
"'cv'",
":",
"i",
",",
"n",
"=",
"env",
".",
"iteration",
",",
"env",
".",
"end_iteration",
"for",
"cvpack",
"in",
"env",
".",
"cvfolds",
":",
"bst",
"=",
"cvpack",
".",
"bst",
"bst",
".",
"set_param",
"(",
"'learning_rate'",
",",
"get_learning_rate",
"(",
"i",
",",
"n",
",",
"learning_rates",
")",
")",
"callback",
".",
"before_iteration",
"=",
"True",
"return",
"callback"
] |
Reset learning rate after iteration 1
NOTE: the initial learning rate will still take in-effect on first iteration.
Parameters
----------
learning_rates: list or function
List of learning rate for each boosting round
or a customized function that calculates eta in terms of
current number of round and the total number of boosting round (e.g.
yields learning rate decay)
* list ``l``: ``eta = l[boosting_round]``
* function ``f``: ``eta = f(boosting_round, num_boost_round)``
Returns
-------
callback : function
The requested callback function.
|
[
"Reset",
"learning",
"rate",
"after",
"iteration",
"1"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/callback.py#L100-L145
|
train
|
dmlc/xgboost
|
python-package/xgboost/callback.py
|
early_stop
|
def early_stop(stopping_rounds, maximize=False, verbose=True):
"""Create a callback that activates early stoppping.
Validation error needs to decrease at least
every **stopping_rounds** round(s) to continue training.
Requires at least one item in **evals**.
If there's more than one, will use the last.
Returns the model from the last iteration (not the best one).
If early stopping occurs, the model will have three additional fields:
``bst.best_score``, ``bst.best_iteration`` and ``bst.best_ntree_limit``.
(Use ``bst.best_ntree_limit`` to get the correct value if ``num_parallel_tree``
and/or ``num_class`` appears in the parameters)
Parameters
----------
stopp_rounds : int
The stopping rounds before the trend occur.
maximize : bool
Whether to maximize evaluation metric.
verbose : optional, bool
Whether to print message about early stopping information.
Returns
-------
callback : function
The requested callback function.
"""
state = {}
def init(env):
"""internal function"""
bst = env.model
if not env.evaluation_result_list:
raise ValueError('For early stopping you need at least one set in evals.')
if len(env.evaluation_result_list) > 1 and verbose:
msg = ("Multiple eval metrics have been passed: "
"'{0}' will be used for early stopping.\n\n")
rabit.tracker_print(msg.format(env.evaluation_result_list[-1][0]))
maximize_metrics = ('auc', 'aucpr', 'map', 'ndcg')
maximize_at_n_metrics = ('auc@', 'aucpr@', 'map@', 'ndcg@')
maximize_score = maximize
metric_label = env.evaluation_result_list[-1][0]
metric = metric_label.split('-', 1)[-1]
if any(metric.startswith(x) for x in maximize_at_n_metrics):
maximize_score = True
if any(metric.split(":")[0] == x for x in maximize_metrics):
maximize_score = True
if verbose and env.rank == 0:
msg = "Will train until {} hasn't improved in {} rounds.\n"
rabit.tracker_print(msg.format(metric_label, stopping_rounds))
state['maximize_score'] = maximize_score
state['best_iteration'] = 0
if maximize_score:
state['best_score'] = float('-inf')
else:
state['best_score'] = float('inf')
if bst is not None:
if bst.attr('best_score') is not None:
state['best_score'] = float(bst.attr('best_score'))
state['best_iteration'] = int(bst.attr('best_iteration'))
state['best_msg'] = bst.attr('best_msg')
else:
bst.set_attr(best_iteration=str(state['best_iteration']))
bst.set_attr(best_score=str(state['best_score']))
else:
assert env.cvfolds is not None
def callback(env):
"""internal function"""
score = env.evaluation_result_list[-1][1]
if not state:
init(env)
best_score = state['best_score']
best_iteration = state['best_iteration']
maximize_score = state['maximize_score']
if (maximize_score and score > best_score) or \
(not maximize_score and score < best_score):
msg = '[%d]\t%s' % (
env.iteration,
'\t'.join([_fmt_metric(x) for x in env.evaluation_result_list]))
state['best_msg'] = msg
state['best_score'] = score
state['best_iteration'] = env.iteration
# save the property to attributes, so they will occur in checkpoint.
if env.model is not None:
env.model.set_attr(best_score=str(state['best_score']),
best_iteration=str(state['best_iteration']),
best_msg=state['best_msg'])
elif env.iteration - best_iteration >= stopping_rounds:
best_msg = state['best_msg']
if verbose and env.rank == 0:
msg = "Stopping. Best iteration:\n{}\n\n"
rabit.tracker_print(msg.format(best_msg))
raise EarlyStopException(best_iteration)
return callback
|
python
|
def early_stop(stopping_rounds, maximize=False, verbose=True):
"""Create a callback that activates early stoppping.
Validation error needs to decrease at least
every **stopping_rounds** round(s) to continue training.
Requires at least one item in **evals**.
If there's more than one, will use the last.
Returns the model from the last iteration (not the best one).
If early stopping occurs, the model will have three additional fields:
``bst.best_score``, ``bst.best_iteration`` and ``bst.best_ntree_limit``.
(Use ``bst.best_ntree_limit`` to get the correct value if ``num_parallel_tree``
and/or ``num_class`` appears in the parameters)
Parameters
----------
stopp_rounds : int
The stopping rounds before the trend occur.
maximize : bool
Whether to maximize evaluation metric.
verbose : optional, bool
Whether to print message about early stopping information.
Returns
-------
callback : function
The requested callback function.
"""
state = {}
def init(env):
"""internal function"""
bst = env.model
if not env.evaluation_result_list:
raise ValueError('For early stopping you need at least one set in evals.')
if len(env.evaluation_result_list) > 1 and verbose:
msg = ("Multiple eval metrics have been passed: "
"'{0}' will be used for early stopping.\n\n")
rabit.tracker_print(msg.format(env.evaluation_result_list[-1][0]))
maximize_metrics = ('auc', 'aucpr', 'map', 'ndcg')
maximize_at_n_metrics = ('auc@', 'aucpr@', 'map@', 'ndcg@')
maximize_score = maximize
metric_label = env.evaluation_result_list[-1][0]
metric = metric_label.split('-', 1)[-1]
if any(metric.startswith(x) for x in maximize_at_n_metrics):
maximize_score = True
if any(metric.split(":")[0] == x for x in maximize_metrics):
maximize_score = True
if verbose and env.rank == 0:
msg = "Will train until {} hasn't improved in {} rounds.\n"
rabit.tracker_print(msg.format(metric_label, stopping_rounds))
state['maximize_score'] = maximize_score
state['best_iteration'] = 0
if maximize_score:
state['best_score'] = float('-inf')
else:
state['best_score'] = float('inf')
if bst is not None:
if bst.attr('best_score') is not None:
state['best_score'] = float(bst.attr('best_score'))
state['best_iteration'] = int(bst.attr('best_iteration'))
state['best_msg'] = bst.attr('best_msg')
else:
bst.set_attr(best_iteration=str(state['best_iteration']))
bst.set_attr(best_score=str(state['best_score']))
else:
assert env.cvfolds is not None
def callback(env):
"""internal function"""
score = env.evaluation_result_list[-1][1]
if not state:
init(env)
best_score = state['best_score']
best_iteration = state['best_iteration']
maximize_score = state['maximize_score']
if (maximize_score and score > best_score) or \
(not maximize_score and score < best_score):
msg = '[%d]\t%s' % (
env.iteration,
'\t'.join([_fmt_metric(x) for x in env.evaluation_result_list]))
state['best_msg'] = msg
state['best_score'] = score
state['best_iteration'] = env.iteration
# save the property to attributes, so they will occur in checkpoint.
if env.model is not None:
env.model.set_attr(best_score=str(state['best_score']),
best_iteration=str(state['best_iteration']),
best_msg=state['best_msg'])
elif env.iteration - best_iteration >= stopping_rounds:
best_msg = state['best_msg']
if verbose and env.rank == 0:
msg = "Stopping. Best iteration:\n{}\n\n"
rabit.tracker_print(msg.format(best_msg))
raise EarlyStopException(best_iteration)
return callback
|
[
"def",
"early_stop",
"(",
"stopping_rounds",
",",
"maximize",
"=",
"False",
",",
"verbose",
"=",
"True",
")",
":",
"state",
"=",
"{",
"}",
"def",
"init",
"(",
"env",
")",
":",
"\"\"\"internal function\"\"\"",
"bst",
"=",
"env",
".",
"model",
"if",
"not",
"env",
".",
"evaluation_result_list",
":",
"raise",
"ValueError",
"(",
"'For early stopping you need at least one set in evals.'",
")",
"if",
"len",
"(",
"env",
".",
"evaluation_result_list",
")",
">",
"1",
"and",
"verbose",
":",
"msg",
"=",
"(",
"\"Multiple eval metrics have been passed: \"",
"\"'{0}' will be used for early stopping.\\n\\n\"",
")",
"rabit",
".",
"tracker_print",
"(",
"msg",
".",
"format",
"(",
"env",
".",
"evaluation_result_list",
"[",
"-",
"1",
"]",
"[",
"0",
"]",
")",
")",
"maximize_metrics",
"=",
"(",
"'auc'",
",",
"'aucpr'",
",",
"'map'",
",",
"'ndcg'",
")",
"maximize_at_n_metrics",
"=",
"(",
"'auc@'",
",",
"'aucpr@'",
",",
"'map@'",
",",
"'ndcg@'",
")",
"maximize_score",
"=",
"maximize",
"metric_label",
"=",
"env",
".",
"evaluation_result_list",
"[",
"-",
"1",
"]",
"[",
"0",
"]",
"metric",
"=",
"metric_label",
".",
"split",
"(",
"'-'",
",",
"1",
")",
"[",
"-",
"1",
"]",
"if",
"any",
"(",
"metric",
".",
"startswith",
"(",
"x",
")",
"for",
"x",
"in",
"maximize_at_n_metrics",
")",
":",
"maximize_score",
"=",
"True",
"if",
"any",
"(",
"metric",
".",
"split",
"(",
"\":\"",
")",
"[",
"0",
"]",
"==",
"x",
"for",
"x",
"in",
"maximize_metrics",
")",
":",
"maximize_score",
"=",
"True",
"if",
"verbose",
"and",
"env",
".",
"rank",
"==",
"0",
":",
"msg",
"=",
"\"Will train until {} hasn't improved in {} rounds.\\n\"",
"rabit",
".",
"tracker_print",
"(",
"msg",
".",
"format",
"(",
"metric_label",
",",
"stopping_rounds",
")",
")",
"state",
"[",
"'maximize_score'",
"]",
"=",
"maximize_score",
"state",
"[",
"'best_iteration'",
"]",
"=",
"0",
"if",
"maximize_score",
":",
"state",
"[",
"'best_score'",
"]",
"=",
"float",
"(",
"'-inf'",
")",
"else",
":",
"state",
"[",
"'best_score'",
"]",
"=",
"float",
"(",
"'inf'",
")",
"if",
"bst",
"is",
"not",
"None",
":",
"if",
"bst",
".",
"attr",
"(",
"'best_score'",
")",
"is",
"not",
"None",
":",
"state",
"[",
"'best_score'",
"]",
"=",
"float",
"(",
"bst",
".",
"attr",
"(",
"'best_score'",
")",
")",
"state",
"[",
"'best_iteration'",
"]",
"=",
"int",
"(",
"bst",
".",
"attr",
"(",
"'best_iteration'",
")",
")",
"state",
"[",
"'best_msg'",
"]",
"=",
"bst",
".",
"attr",
"(",
"'best_msg'",
")",
"else",
":",
"bst",
".",
"set_attr",
"(",
"best_iteration",
"=",
"str",
"(",
"state",
"[",
"'best_iteration'",
"]",
")",
")",
"bst",
".",
"set_attr",
"(",
"best_score",
"=",
"str",
"(",
"state",
"[",
"'best_score'",
"]",
")",
")",
"else",
":",
"assert",
"env",
".",
"cvfolds",
"is",
"not",
"None",
"def",
"callback",
"(",
"env",
")",
":",
"\"\"\"internal function\"\"\"",
"score",
"=",
"env",
".",
"evaluation_result_list",
"[",
"-",
"1",
"]",
"[",
"1",
"]",
"if",
"not",
"state",
":",
"init",
"(",
"env",
")",
"best_score",
"=",
"state",
"[",
"'best_score'",
"]",
"best_iteration",
"=",
"state",
"[",
"'best_iteration'",
"]",
"maximize_score",
"=",
"state",
"[",
"'maximize_score'",
"]",
"if",
"(",
"maximize_score",
"and",
"score",
">",
"best_score",
")",
"or",
"(",
"not",
"maximize_score",
"and",
"score",
"<",
"best_score",
")",
":",
"msg",
"=",
"'[%d]\\t%s'",
"%",
"(",
"env",
".",
"iteration",
",",
"'\\t'",
".",
"join",
"(",
"[",
"_fmt_metric",
"(",
"x",
")",
"for",
"x",
"in",
"env",
".",
"evaluation_result_list",
"]",
")",
")",
"state",
"[",
"'best_msg'",
"]",
"=",
"msg",
"state",
"[",
"'best_score'",
"]",
"=",
"score",
"state",
"[",
"'best_iteration'",
"]",
"=",
"env",
".",
"iteration",
"# save the property to attributes, so they will occur in checkpoint.",
"if",
"env",
".",
"model",
"is",
"not",
"None",
":",
"env",
".",
"model",
".",
"set_attr",
"(",
"best_score",
"=",
"str",
"(",
"state",
"[",
"'best_score'",
"]",
")",
",",
"best_iteration",
"=",
"str",
"(",
"state",
"[",
"'best_iteration'",
"]",
")",
",",
"best_msg",
"=",
"state",
"[",
"'best_msg'",
"]",
")",
"elif",
"env",
".",
"iteration",
"-",
"best_iteration",
">=",
"stopping_rounds",
":",
"best_msg",
"=",
"state",
"[",
"'best_msg'",
"]",
"if",
"verbose",
"and",
"env",
".",
"rank",
"==",
"0",
":",
"msg",
"=",
"\"Stopping. Best iteration:\\n{}\\n\\n\"",
"rabit",
".",
"tracker_print",
"(",
"msg",
".",
"format",
"(",
"best_msg",
")",
")",
"raise",
"EarlyStopException",
"(",
"best_iteration",
")",
"return",
"callback"
] |
Create a callback that activates early stoppping.
Validation error needs to decrease at least
every **stopping_rounds** round(s) to continue training.
Requires at least one item in **evals**.
If there's more than one, will use the last.
Returns the model from the last iteration (not the best one).
If early stopping occurs, the model will have three additional fields:
``bst.best_score``, ``bst.best_iteration`` and ``bst.best_ntree_limit``.
(Use ``bst.best_ntree_limit`` to get the correct value if ``num_parallel_tree``
and/or ``num_class`` appears in the parameters)
Parameters
----------
stopp_rounds : int
The stopping rounds before the trend occur.
maximize : bool
Whether to maximize evaluation metric.
verbose : optional, bool
Whether to print message about early stopping information.
Returns
-------
callback : function
The requested callback function.
|
[
"Create",
"a",
"callback",
"that",
"activates",
"early",
"stoppping",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/callback.py#L148-L250
|
train
|
dmlc/xgboost
|
doc/conf.py
|
run_doxygen
|
def run_doxygen(folder):
"""Run the doxygen make command in the designated folder."""
try:
retcode = subprocess.call("cd %s; make doxygen" % folder, shell=True)
if retcode < 0:
sys.stderr.write("doxygen terminated by signal %s" % (-retcode))
except OSError as e:
sys.stderr.write("doxygen execution failed: %s" % e)
|
python
|
def run_doxygen(folder):
"""Run the doxygen make command in the designated folder."""
try:
retcode = subprocess.call("cd %s; make doxygen" % folder, shell=True)
if retcode < 0:
sys.stderr.write("doxygen terminated by signal %s" % (-retcode))
except OSError as e:
sys.stderr.write("doxygen execution failed: %s" % e)
|
[
"def",
"run_doxygen",
"(",
"folder",
")",
":",
"try",
":",
"retcode",
"=",
"subprocess",
".",
"call",
"(",
"\"cd %s; make doxygen\"",
"%",
"folder",
",",
"shell",
"=",
"True",
")",
"if",
"retcode",
"<",
"0",
":",
"sys",
".",
"stderr",
".",
"write",
"(",
"\"doxygen terminated by signal %s\"",
"%",
"(",
"-",
"retcode",
")",
")",
"except",
"OSError",
"as",
"e",
":",
"sys",
".",
"stderr",
".",
"write",
"(",
"\"doxygen execution failed: %s\"",
"%",
"e",
")"
] |
Run the doxygen make command in the designated folder.
|
[
"Run",
"the",
"doxygen",
"make",
"command",
"in",
"the",
"designated",
"folder",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/doc/conf.py#L196-L203
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
_objective_decorator
|
def _objective_decorator(func):
"""Decorate an objective function
Converts an objective function using the typical sklearn metrics
signature so that it is usable with ``xgboost.training.train``
Parameters
----------
func: callable
Expects a callable with signature ``func(y_true, y_pred)``:
y_true: array_like of shape [n_samples]
The target values
y_pred: array_like of shape [n_samples]
The predicted values
Returns
-------
new_func: callable
The new objective function as expected by ``xgboost.training.train``.
The signature is ``new_func(preds, dmatrix)``:
preds: array_like, shape [n_samples]
The predicted values
dmatrix: ``DMatrix``
The training set from which the labels will be extracted using
``dmatrix.get_label()``
"""
def inner(preds, dmatrix):
"""internal function"""
labels = dmatrix.get_label()
return func(labels, preds)
return inner
|
python
|
def _objective_decorator(func):
"""Decorate an objective function
Converts an objective function using the typical sklearn metrics
signature so that it is usable with ``xgboost.training.train``
Parameters
----------
func: callable
Expects a callable with signature ``func(y_true, y_pred)``:
y_true: array_like of shape [n_samples]
The target values
y_pred: array_like of shape [n_samples]
The predicted values
Returns
-------
new_func: callable
The new objective function as expected by ``xgboost.training.train``.
The signature is ``new_func(preds, dmatrix)``:
preds: array_like, shape [n_samples]
The predicted values
dmatrix: ``DMatrix``
The training set from which the labels will be extracted using
``dmatrix.get_label()``
"""
def inner(preds, dmatrix):
"""internal function"""
labels = dmatrix.get_label()
return func(labels, preds)
return inner
|
[
"def",
"_objective_decorator",
"(",
"func",
")",
":",
"def",
"inner",
"(",
"preds",
",",
"dmatrix",
")",
":",
"\"\"\"internal function\"\"\"",
"labels",
"=",
"dmatrix",
".",
"get_label",
"(",
")",
"return",
"func",
"(",
"labels",
",",
"preds",
")",
"return",
"inner"
] |
Decorate an objective function
Converts an objective function using the typical sklearn metrics
signature so that it is usable with ``xgboost.training.train``
Parameters
----------
func: callable
Expects a callable with signature ``func(y_true, y_pred)``:
y_true: array_like of shape [n_samples]
The target values
y_pred: array_like of shape [n_samples]
The predicted values
Returns
-------
new_func: callable
The new objective function as expected by ``xgboost.training.train``.
The signature is ``new_func(preds, dmatrix)``:
preds: array_like, shape [n_samples]
The predicted values
dmatrix: ``DMatrix``
The training set from which the labels will be extracted using
``dmatrix.get_label()``
|
[
"Decorate",
"an",
"objective",
"function"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L18-L50
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBModel.set_params
|
def set_params(self, **params):
"""Set the parameters of this estimator.
Modification of the sklearn method to allow unknown kwargs. This allows using
the full range of xgboost parameters that are not defined as member variables
in sklearn grid search.
Returns
-------
self
"""
if not params:
# Simple optimization to gain speed (inspect is slow)
return self
for key, value in params.items():
if hasattr(self, key):
setattr(self, key, value)
else:
self.kwargs[key] = value
return self
|
python
|
def set_params(self, **params):
"""Set the parameters of this estimator.
Modification of the sklearn method to allow unknown kwargs. This allows using
the full range of xgboost parameters that are not defined as member variables
in sklearn grid search.
Returns
-------
self
"""
if not params:
# Simple optimization to gain speed (inspect is slow)
return self
for key, value in params.items():
if hasattr(self, key):
setattr(self, key, value)
else:
self.kwargs[key] = value
return self
|
[
"def",
"set_params",
"(",
"self",
",",
"*",
"*",
"params",
")",
":",
"if",
"not",
"params",
":",
"# Simple optimization to gain speed (inspect is slow)",
"return",
"self",
"for",
"key",
",",
"value",
"in",
"params",
".",
"items",
"(",
")",
":",
"if",
"hasattr",
"(",
"self",
",",
"key",
")",
":",
"setattr",
"(",
"self",
",",
"key",
",",
"value",
")",
"else",
":",
"self",
".",
"kwargs",
"[",
"key",
"]",
"=",
"value",
"return",
"self"
] |
Set the parameters of this estimator.
Modification of the sklearn method to allow unknown kwargs. This allows using
the full range of xgboost parameters that are not defined as member variables
in sklearn grid search.
Returns
-------
self
|
[
"Set",
"the",
"parameters",
"of",
"this",
"estimator",
".",
"Modification",
"of",
"the",
"sklearn",
"method",
"to",
"allow",
"unknown",
"kwargs",
".",
"This",
"allows",
"using",
"the",
"full",
"range",
"of",
"xgboost",
"parameters",
"that",
"are",
"not",
"defined",
"as",
"member",
"variables",
"in",
"sklearn",
"grid",
"search",
".",
"Returns",
"-------",
"self"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L196-L215
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBModel.get_params
|
def get_params(self, deep=False):
"""Get parameters."""
params = super(XGBModel, self).get_params(deep=deep)
if isinstance(self.kwargs, dict): # if kwargs is a dict, update params accordingly
params.update(self.kwargs)
if params['missing'] is np.nan:
params['missing'] = None # sklearn doesn't handle nan. see #4725
if not params.get('eval_metric', True):
del params['eval_metric'] # don't give as None param to Booster
return params
|
python
|
def get_params(self, deep=False):
"""Get parameters."""
params = super(XGBModel, self).get_params(deep=deep)
if isinstance(self.kwargs, dict): # if kwargs is a dict, update params accordingly
params.update(self.kwargs)
if params['missing'] is np.nan:
params['missing'] = None # sklearn doesn't handle nan. see #4725
if not params.get('eval_metric', True):
del params['eval_metric'] # don't give as None param to Booster
return params
|
[
"def",
"get_params",
"(",
"self",
",",
"deep",
"=",
"False",
")",
":",
"params",
"=",
"super",
"(",
"XGBModel",
",",
"self",
")",
".",
"get_params",
"(",
"deep",
"=",
"deep",
")",
"if",
"isinstance",
"(",
"self",
".",
"kwargs",
",",
"dict",
")",
":",
"# if kwargs is a dict, update params accordingly",
"params",
".",
"update",
"(",
"self",
".",
"kwargs",
")",
"if",
"params",
"[",
"'missing'",
"]",
"is",
"np",
".",
"nan",
":",
"params",
"[",
"'missing'",
"]",
"=",
"None",
"# sklearn doesn't handle nan. see #4725",
"if",
"not",
"params",
".",
"get",
"(",
"'eval_metric'",
",",
"True",
")",
":",
"del",
"params",
"[",
"'eval_metric'",
"]",
"# don't give as None param to Booster",
"return",
"params"
] |
Get parameters.
|
[
"Get",
"parameters",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L217-L226
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBModel.get_xgb_params
|
def get_xgb_params(self):
"""Get xgboost type parameters."""
xgb_params = self.get_params()
random_state = xgb_params.pop('random_state')
if 'seed' in xgb_params and xgb_params['seed'] is not None:
warnings.warn('The seed parameter is deprecated as of version .6.'
'Please use random_state instead.'
'seed is deprecated.', DeprecationWarning)
else:
xgb_params['seed'] = random_state
n_jobs = xgb_params.pop('n_jobs')
if 'nthread' in xgb_params and xgb_params['nthread'] is not None:
warnings.warn('The nthread parameter is deprecated as of version .6.'
'Please use n_jobs instead.'
'nthread is deprecated.', DeprecationWarning)
else:
xgb_params['nthread'] = n_jobs
if 'silent' in xgb_params and xgb_params['silent'] is not None:
warnings.warn('The silent parameter is deprecated.'
'Please use verbosity instead.'
'silent is depreated', DeprecationWarning)
# TODO(canonizer): set verbosity explicitly if silent is removed from xgboost,
# but remains in this API
else:
# silent=None shouldn't be passed to xgboost
xgb_params.pop('silent', None)
if xgb_params['nthread'] <= 0:
xgb_params.pop('nthread', None)
return xgb_params
|
python
|
def get_xgb_params(self):
"""Get xgboost type parameters."""
xgb_params = self.get_params()
random_state = xgb_params.pop('random_state')
if 'seed' in xgb_params and xgb_params['seed'] is not None:
warnings.warn('The seed parameter is deprecated as of version .6.'
'Please use random_state instead.'
'seed is deprecated.', DeprecationWarning)
else:
xgb_params['seed'] = random_state
n_jobs = xgb_params.pop('n_jobs')
if 'nthread' in xgb_params and xgb_params['nthread'] is not None:
warnings.warn('The nthread parameter is deprecated as of version .6.'
'Please use n_jobs instead.'
'nthread is deprecated.', DeprecationWarning)
else:
xgb_params['nthread'] = n_jobs
if 'silent' in xgb_params and xgb_params['silent'] is not None:
warnings.warn('The silent parameter is deprecated.'
'Please use verbosity instead.'
'silent is depreated', DeprecationWarning)
# TODO(canonizer): set verbosity explicitly if silent is removed from xgboost,
# but remains in this API
else:
# silent=None shouldn't be passed to xgboost
xgb_params.pop('silent', None)
if xgb_params['nthread'] <= 0:
xgb_params.pop('nthread', None)
return xgb_params
|
[
"def",
"get_xgb_params",
"(",
"self",
")",
":",
"xgb_params",
"=",
"self",
".",
"get_params",
"(",
")",
"random_state",
"=",
"xgb_params",
".",
"pop",
"(",
"'random_state'",
")",
"if",
"'seed'",
"in",
"xgb_params",
"and",
"xgb_params",
"[",
"'seed'",
"]",
"is",
"not",
"None",
":",
"warnings",
".",
"warn",
"(",
"'The seed parameter is deprecated as of version .6.'",
"'Please use random_state instead.'",
"'seed is deprecated.'",
",",
"DeprecationWarning",
")",
"else",
":",
"xgb_params",
"[",
"'seed'",
"]",
"=",
"random_state",
"n_jobs",
"=",
"xgb_params",
".",
"pop",
"(",
"'n_jobs'",
")",
"if",
"'nthread'",
"in",
"xgb_params",
"and",
"xgb_params",
"[",
"'nthread'",
"]",
"is",
"not",
"None",
":",
"warnings",
".",
"warn",
"(",
"'The nthread parameter is deprecated as of version .6.'",
"'Please use n_jobs instead.'",
"'nthread is deprecated.'",
",",
"DeprecationWarning",
")",
"else",
":",
"xgb_params",
"[",
"'nthread'",
"]",
"=",
"n_jobs",
"if",
"'silent'",
"in",
"xgb_params",
"and",
"xgb_params",
"[",
"'silent'",
"]",
"is",
"not",
"None",
":",
"warnings",
".",
"warn",
"(",
"'The silent parameter is deprecated.'",
"'Please use verbosity instead.'",
"'silent is depreated'",
",",
"DeprecationWarning",
")",
"# TODO(canonizer): set verbosity explicitly if silent is removed from xgboost,",
"# but remains in this API",
"else",
":",
"# silent=None shouldn't be passed to xgboost",
"xgb_params",
".",
"pop",
"(",
"'silent'",
",",
"None",
")",
"if",
"xgb_params",
"[",
"'nthread'",
"]",
"<=",
"0",
":",
"xgb_params",
".",
"pop",
"(",
"'nthread'",
",",
"None",
")",
"return",
"xgb_params"
] |
Get xgboost type parameters.
|
[
"Get",
"xgboost",
"type",
"parameters",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L228-L258
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBModel.load_model
|
def load_model(self, fname):
"""
Load the model from a file.
The model is loaded from an XGBoost internal binary format which is
universal among the various XGBoost interfaces. Auxiliary attributes of
the Python Booster object (such as feature names) will not be loaded.
Label encodings (text labels to numeric labels) will be also lost.
**If you are using only the Python interface, we recommend pickling the
model object for best results.**
Parameters
----------
fname : string or a memory buffer
Input file name or memory buffer(see also save_raw)
"""
if self._Booster is None:
self._Booster = Booster({'nthread': self.n_jobs})
self._Booster.load_model(fname)
|
python
|
def load_model(self, fname):
"""
Load the model from a file.
The model is loaded from an XGBoost internal binary format which is
universal among the various XGBoost interfaces. Auxiliary attributes of
the Python Booster object (such as feature names) will not be loaded.
Label encodings (text labels to numeric labels) will be also lost.
**If you are using only the Python interface, we recommend pickling the
model object for best results.**
Parameters
----------
fname : string or a memory buffer
Input file name or memory buffer(see also save_raw)
"""
if self._Booster is None:
self._Booster = Booster({'nthread': self.n_jobs})
self._Booster.load_model(fname)
|
[
"def",
"load_model",
"(",
"self",
",",
"fname",
")",
":",
"if",
"self",
".",
"_Booster",
"is",
"None",
":",
"self",
".",
"_Booster",
"=",
"Booster",
"(",
"{",
"'nthread'",
":",
"self",
".",
"n_jobs",
"}",
")",
"self",
".",
"_Booster",
".",
"load_model",
"(",
"fname",
")"
] |
Load the model from a file.
The model is loaded from an XGBoost internal binary format which is
universal among the various XGBoost interfaces. Auxiliary attributes of
the Python Booster object (such as feature names) will not be loaded.
Label encodings (text labels to numeric labels) will be also lost.
**If you are using only the Python interface, we recommend pickling the
model object for best results.**
Parameters
----------
fname : string or a memory buffer
Input file name or memory buffer(see also save_raw)
|
[
"Load",
"the",
"model",
"from",
"a",
"file",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L282-L300
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBModel.fit
|
def fit(self, X, y, sample_weight=None, eval_set=None, eval_metric=None,
early_stopping_rounds=None, verbose=True, xgb_model=None,
sample_weight_eval_set=None, callbacks=None):
# pylint: disable=missing-docstring,invalid-name,attribute-defined-outside-init
"""
Fit the gradient boosting model
Parameters
----------
X : array_like
Feature matrix
y : array_like
Labels
sample_weight : array_like
instance weights
eval_set : list, optional
A list of (X, y) tuple pairs to use as a validation set for
early-stopping
sample_weight_eval_set : list, optional
A list of the form [L_1, L_2, ..., L_n], where each L_i is a list of
instance weights on the i-th validation set.
eval_metric : str, callable, optional
If a str, should be a built-in evaluation metric to use. See
doc/parameter.rst. If callable, a custom evaluation metric. The call
signature is func(y_predicted, y_true) where y_true will be a
DMatrix object such that you may need to call the get_label
method. It must return a str, value pair where the str is a name
for the evaluation and value is the value of the evaluation
function. This objective is always minimized.
early_stopping_rounds : int
Activates early stopping. Validation error needs to decrease at
least every <early_stopping_rounds> round(s) to continue training.
Requires at least one item in evals. If there's more than one,
will use the last. Returns the model from the last iteration
(not the best one). If early stopping occurs, the model will
have three additional fields: bst.best_score, bst.best_iteration
and bst.best_ntree_limit.
(Use bst.best_ntree_limit to get the correct value if num_parallel_tree
and/or num_class appears in the parameters)
verbose : bool
If `verbose` and an evaluation set is used, writes the evaluation
metric measured on the validation set to stderr.
xgb_model : str
file name of stored xgb model or 'Booster' instance Xgb model to be
loaded before training (allows training continuation).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using :ref:`callback_api`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
"""
if sample_weight is not None:
trainDmatrix = DMatrix(X, label=y, weight=sample_weight,
missing=self.missing, nthread=self.n_jobs)
else:
trainDmatrix = DMatrix(X, label=y, missing=self.missing, nthread=self.n_jobs)
evals_result = {}
if eval_set is not None:
if sample_weight_eval_set is None:
sample_weight_eval_set = [None] * len(eval_set)
evals = list(
DMatrix(eval_set[i][0], label=eval_set[i][1], missing=self.missing,
weight=sample_weight_eval_set[i], nthread=self.n_jobs)
for i in range(len(eval_set)))
evals = list(zip(evals, ["validation_{}".format(i) for i in
range(len(evals))]))
else:
evals = ()
params = self.get_xgb_params()
if callable(self.objective):
obj = _objective_decorator(self.objective)
params["objective"] = "reg:linear"
else:
obj = None
feval = eval_metric if callable(eval_metric) else None
if eval_metric is not None:
if callable(eval_metric):
eval_metric = None
else:
params.update({'eval_metric': eval_metric})
self._Booster = train(params, trainDmatrix,
self.get_num_boosting_rounds(), evals=evals,
early_stopping_rounds=early_stopping_rounds,
evals_result=evals_result, obj=obj, feval=feval,
verbose_eval=verbose, xgb_model=xgb_model,
callbacks=callbacks)
if evals_result:
for val in evals_result.items():
evals_result_key = list(val[1].keys())[0]
evals_result[val[0]][evals_result_key] = val[1][evals_result_key]
self.evals_result_ = evals_result
if early_stopping_rounds is not None:
self.best_score = self._Booster.best_score
self.best_iteration = self._Booster.best_iteration
self.best_ntree_limit = self._Booster.best_ntree_limit
return self
|
python
|
def fit(self, X, y, sample_weight=None, eval_set=None, eval_metric=None,
early_stopping_rounds=None, verbose=True, xgb_model=None,
sample_weight_eval_set=None, callbacks=None):
# pylint: disable=missing-docstring,invalid-name,attribute-defined-outside-init
"""
Fit the gradient boosting model
Parameters
----------
X : array_like
Feature matrix
y : array_like
Labels
sample_weight : array_like
instance weights
eval_set : list, optional
A list of (X, y) tuple pairs to use as a validation set for
early-stopping
sample_weight_eval_set : list, optional
A list of the form [L_1, L_2, ..., L_n], where each L_i is a list of
instance weights on the i-th validation set.
eval_metric : str, callable, optional
If a str, should be a built-in evaluation metric to use. See
doc/parameter.rst. If callable, a custom evaluation metric. The call
signature is func(y_predicted, y_true) where y_true will be a
DMatrix object such that you may need to call the get_label
method. It must return a str, value pair where the str is a name
for the evaluation and value is the value of the evaluation
function. This objective is always minimized.
early_stopping_rounds : int
Activates early stopping. Validation error needs to decrease at
least every <early_stopping_rounds> round(s) to continue training.
Requires at least one item in evals. If there's more than one,
will use the last. Returns the model from the last iteration
(not the best one). If early stopping occurs, the model will
have three additional fields: bst.best_score, bst.best_iteration
and bst.best_ntree_limit.
(Use bst.best_ntree_limit to get the correct value if num_parallel_tree
and/or num_class appears in the parameters)
verbose : bool
If `verbose` and an evaluation set is used, writes the evaluation
metric measured on the validation set to stderr.
xgb_model : str
file name of stored xgb model or 'Booster' instance Xgb model to be
loaded before training (allows training continuation).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using :ref:`callback_api`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
"""
if sample_weight is not None:
trainDmatrix = DMatrix(X, label=y, weight=sample_weight,
missing=self.missing, nthread=self.n_jobs)
else:
trainDmatrix = DMatrix(X, label=y, missing=self.missing, nthread=self.n_jobs)
evals_result = {}
if eval_set is not None:
if sample_weight_eval_set is None:
sample_weight_eval_set = [None] * len(eval_set)
evals = list(
DMatrix(eval_set[i][0], label=eval_set[i][1], missing=self.missing,
weight=sample_weight_eval_set[i], nthread=self.n_jobs)
for i in range(len(eval_set)))
evals = list(zip(evals, ["validation_{}".format(i) for i in
range(len(evals))]))
else:
evals = ()
params = self.get_xgb_params()
if callable(self.objective):
obj = _objective_decorator(self.objective)
params["objective"] = "reg:linear"
else:
obj = None
feval = eval_metric if callable(eval_metric) else None
if eval_metric is not None:
if callable(eval_metric):
eval_metric = None
else:
params.update({'eval_metric': eval_metric})
self._Booster = train(params, trainDmatrix,
self.get_num_boosting_rounds(), evals=evals,
early_stopping_rounds=early_stopping_rounds,
evals_result=evals_result, obj=obj, feval=feval,
verbose_eval=verbose, xgb_model=xgb_model,
callbacks=callbacks)
if evals_result:
for val in evals_result.items():
evals_result_key = list(val[1].keys())[0]
evals_result[val[0]][evals_result_key] = val[1][evals_result_key]
self.evals_result_ = evals_result
if early_stopping_rounds is not None:
self.best_score = self._Booster.best_score
self.best_iteration = self._Booster.best_iteration
self.best_ntree_limit = self._Booster.best_ntree_limit
return self
|
[
"def",
"fit",
"(",
"self",
",",
"X",
",",
"y",
",",
"sample_weight",
"=",
"None",
",",
"eval_set",
"=",
"None",
",",
"eval_metric",
"=",
"None",
",",
"early_stopping_rounds",
"=",
"None",
",",
"verbose",
"=",
"True",
",",
"xgb_model",
"=",
"None",
",",
"sample_weight_eval_set",
"=",
"None",
",",
"callbacks",
"=",
"None",
")",
":",
"# pylint: disable=missing-docstring,invalid-name,attribute-defined-outside-init",
"if",
"sample_weight",
"is",
"not",
"None",
":",
"trainDmatrix",
"=",
"DMatrix",
"(",
"X",
",",
"label",
"=",
"y",
",",
"weight",
"=",
"sample_weight",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"else",
":",
"trainDmatrix",
"=",
"DMatrix",
"(",
"X",
",",
"label",
"=",
"y",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"evals_result",
"=",
"{",
"}",
"if",
"eval_set",
"is",
"not",
"None",
":",
"if",
"sample_weight_eval_set",
"is",
"None",
":",
"sample_weight_eval_set",
"=",
"[",
"None",
"]",
"*",
"len",
"(",
"eval_set",
")",
"evals",
"=",
"list",
"(",
"DMatrix",
"(",
"eval_set",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"label",
"=",
"eval_set",
"[",
"i",
"]",
"[",
"1",
"]",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"weight",
"=",
"sample_weight_eval_set",
"[",
"i",
"]",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"eval_set",
")",
")",
")",
"evals",
"=",
"list",
"(",
"zip",
"(",
"evals",
",",
"[",
"\"validation_{}\"",
".",
"format",
"(",
"i",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"evals",
")",
")",
"]",
")",
")",
"else",
":",
"evals",
"=",
"(",
")",
"params",
"=",
"self",
".",
"get_xgb_params",
"(",
")",
"if",
"callable",
"(",
"self",
".",
"objective",
")",
":",
"obj",
"=",
"_objective_decorator",
"(",
"self",
".",
"objective",
")",
"params",
"[",
"\"objective\"",
"]",
"=",
"\"reg:linear\"",
"else",
":",
"obj",
"=",
"None",
"feval",
"=",
"eval_metric",
"if",
"callable",
"(",
"eval_metric",
")",
"else",
"None",
"if",
"eval_metric",
"is",
"not",
"None",
":",
"if",
"callable",
"(",
"eval_metric",
")",
":",
"eval_metric",
"=",
"None",
"else",
":",
"params",
".",
"update",
"(",
"{",
"'eval_metric'",
":",
"eval_metric",
"}",
")",
"self",
".",
"_Booster",
"=",
"train",
"(",
"params",
",",
"trainDmatrix",
",",
"self",
".",
"get_num_boosting_rounds",
"(",
")",
",",
"evals",
"=",
"evals",
",",
"early_stopping_rounds",
"=",
"early_stopping_rounds",
",",
"evals_result",
"=",
"evals_result",
",",
"obj",
"=",
"obj",
",",
"feval",
"=",
"feval",
",",
"verbose_eval",
"=",
"verbose",
",",
"xgb_model",
"=",
"xgb_model",
",",
"callbacks",
"=",
"callbacks",
")",
"if",
"evals_result",
":",
"for",
"val",
"in",
"evals_result",
".",
"items",
"(",
")",
":",
"evals_result_key",
"=",
"list",
"(",
"val",
"[",
"1",
"]",
".",
"keys",
"(",
")",
")",
"[",
"0",
"]",
"evals_result",
"[",
"val",
"[",
"0",
"]",
"]",
"[",
"evals_result_key",
"]",
"=",
"val",
"[",
"1",
"]",
"[",
"evals_result_key",
"]",
"self",
".",
"evals_result_",
"=",
"evals_result",
"if",
"early_stopping_rounds",
"is",
"not",
"None",
":",
"self",
".",
"best_score",
"=",
"self",
".",
"_Booster",
".",
"best_score",
"self",
".",
"best_iteration",
"=",
"self",
".",
"_Booster",
".",
"best_iteration",
"self",
".",
"best_ntree_limit",
"=",
"self",
".",
"_Booster",
".",
"best_ntree_limit",
"return",
"self"
] |
Fit the gradient boosting model
Parameters
----------
X : array_like
Feature matrix
y : array_like
Labels
sample_weight : array_like
instance weights
eval_set : list, optional
A list of (X, y) tuple pairs to use as a validation set for
early-stopping
sample_weight_eval_set : list, optional
A list of the form [L_1, L_2, ..., L_n], where each L_i is a list of
instance weights on the i-th validation set.
eval_metric : str, callable, optional
If a str, should be a built-in evaluation metric to use. See
doc/parameter.rst. If callable, a custom evaluation metric. The call
signature is func(y_predicted, y_true) where y_true will be a
DMatrix object such that you may need to call the get_label
method. It must return a str, value pair where the str is a name
for the evaluation and value is the value of the evaluation
function. This objective is always minimized.
early_stopping_rounds : int
Activates early stopping. Validation error needs to decrease at
least every <early_stopping_rounds> round(s) to continue training.
Requires at least one item in evals. If there's more than one,
will use the last. Returns the model from the last iteration
(not the best one). If early stopping occurs, the model will
have three additional fields: bst.best_score, bst.best_iteration
and bst.best_ntree_limit.
(Use bst.best_ntree_limit to get the correct value if num_parallel_tree
and/or num_class appears in the parameters)
verbose : bool
If `verbose` and an evaluation set is used, writes the evaluation
metric measured on the validation set to stderr.
xgb_model : str
file name of stored xgb model or 'Booster' instance Xgb model to be
loaded before training (allows training continuation).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using :ref:`callback_api`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
|
[
"Fit",
"the",
"gradient",
"boosting",
"model"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L302-L408
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBModel.predict
|
def predict(self, data, output_margin=False, ntree_limit=None, validate_features=True):
"""
Predict with `data`.
.. note:: This function is not thread safe.
For each booster object, predict can only be called from one thread.
If you want to run prediction using multiple thread, call ``xgb.copy()`` to make copies
of model object and then call ``predict()``.
.. note:: Using ``predict()`` with DART booster
If the booster object is DART type, ``predict()`` will perform dropouts, i.e. only
some of the trees will be evaluated. This will produce incorrect results if ``data`` is
not the training data. To obtain correct results on test sets, set ``ntree_limit`` to
a nonzero value, e.g.
.. code-block:: python
preds = bst.predict(dtest, ntree_limit=num_round)
Parameters
----------
data : DMatrix
The dmatrix storing the input.
output_margin : bool
Whether to output the raw untransformed margin value.
ntree_limit : int
Limit number of trees in the prediction; defaults to best_ntree_limit if defined
(i.e. it has been trained with early stopping), otherwise 0 (use all trees).
validate_features : bool
When this is True, validate that the Booster's and data's feature_names are identical.
Otherwise, it is assumed that the feature_names are the same.
Returns
-------
prediction : numpy array
"""
# pylint: disable=missing-docstring,invalid-name
test_dmatrix = DMatrix(data, missing=self.missing, nthread=self.n_jobs)
# get ntree_limit to use - if none specified, default to
# best_ntree_limit if defined, otherwise 0.
if ntree_limit is None:
ntree_limit = getattr(self, "best_ntree_limit", 0)
return self.get_booster().predict(test_dmatrix,
output_margin=output_margin,
ntree_limit=ntree_limit,
validate_features=validate_features)
|
python
|
def predict(self, data, output_margin=False, ntree_limit=None, validate_features=True):
"""
Predict with `data`.
.. note:: This function is not thread safe.
For each booster object, predict can only be called from one thread.
If you want to run prediction using multiple thread, call ``xgb.copy()`` to make copies
of model object and then call ``predict()``.
.. note:: Using ``predict()`` with DART booster
If the booster object is DART type, ``predict()`` will perform dropouts, i.e. only
some of the trees will be evaluated. This will produce incorrect results if ``data`` is
not the training data. To obtain correct results on test sets, set ``ntree_limit`` to
a nonzero value, e.g.
.. code-block:: python
preds = bst.predict(dtest, ntree_limit=num_round)
Parameters
----------
data : DMatrix
The dmatrix storing the input.
output_margin : bool
Whether to output the raw untransformed margin value.
ntree_limit : int
Limit number of trees in the prediction; defaults to best_ntree_limit if defined
(i.e. it has been trained with early stopping), otherwise 0 (use all trees).
validate_features : bool
When this is True, validate that the Booster's and data's feature_names are identical.
Otherwise, it is assumed that the feature_names are the same.
Returns
-------
prediction : numpy array
"""
# pylint: disable=missing-docstring,invalid-name
test_dmatrix = DMatrix(data, missing=self.missing, nthread=self.n_jobs)
# get ntree_limit to use - if none specified, default to
# best_ntree_limit if defined, otherwise 0.
if ntree_limit is None:
ntree_limit = getattr(self, "best_ntree_limit", 0)
return self.get_booster().predict(test_dmatrix,
output_margin=output_margin,
ntree_limit=ntree_limit,
validate_features=validate_features)
|
[
"def",
"predict",
"(",
"self",
",",
"data",
",",
"output_margin",
"=",
"False",
",",
"ntree_limit",
"=",
"None",
",",
"validate_features",
"=",
"True",
")",
":",
"# pylint: disable=missing-docstring,invalid-name",
"test_dmatrix",
"=",
"DMatrix",
"(",
"data",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"# get ntree_limit to use - if none specified, default to",
"# best_ntree_limit if defined, otherwise 0.",
"if",
"ntree_limit",
"is",
"None",
":",
"ntree_limit",
"=",
"getattr",
"(",
"self",
",",
"\"best_ntree_limit\"",
",",
"0",
")",
"return",
"self",
".",
"get_booster",
"(",
")",
".",
"predict",
"(",
"test_dmatrix",
",",
"output_margin",
"=",
"output_margin",
",",
"ntree_limit",
"=",
"ntree_limit",
",",
"validate_features",
"=",
"validate_features",
")"
] |
Predict with `data`.
.. note:: This function is not thread safe.
For each booster object, predict can only be called from one thread.
If you want to run prediction using multiple thread, call ``xgb.copy()`` to make copies
of model object and then call ``predict()``.
.. note:: Using ``predict()`` with DART booster
If the booster object is DART type, ``predict()`` will perform dropouts, i.e. only
some of the trees will be evaluated. This will produce incorrect results if ``data`` is
not the training data. To obtain correct results on test sets, set ``ntree_limit`` to
a nonzero value, e.g.
.. code-block:: python
preds = bst.predict(dtest, ntree_limit=num_round)
Parameters
----------
data : DMatrix
The dmatrix storing the input.
output_margin : bool
Whether to output the raw untransformed margin value.
ntree_limit : int
Limit number of trees in the prediction; defaults to best_ntree_limit if defined
(i.e. it has been trained with early stopping), otherwise 0 (use all trees).
validate_features : bool
When this is True, validate that the Booster's and data's feature_names are identical.
Otherwise, it is assumed that the feature_names are the same.
Returns
-------
prediction : numpy array
|
[
"Predict",
"with",
"data",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L410-L456
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBModel.apply
|
def apply(self, X, ntree_limit=0):
"""Return the predicted leaf every tree for each sample.
Parameters
----------
X : array_like, shape=[n_samples, n_features]
Input features matrix.
ntree_limit : int
Limit number of trees in the prediction; defaults to 0 (use all trees).
Returns
-------
X_leaves : array_like, shape=[n_samples, n_trees]
For each datapoint x in X and for each tree, return the index of the
leaf x ends up in. Leaves are numbered within
``[0; 2**(self.max_depth+1))``, possibly with gaps in the numbering.
"""
test_dmatrix = DMatrix(X, missing=self.missing, nthread=self.n_jobs)
return self.get_booster().predict(test_dmatrix,
pred_leaf=True,
ntree_limit=ntree_limit)
|
python
|
def apply(self, X, ntree_limit=0):
"""Return the predicted leaf every tree for each sample.
Parameters
----------
X : array_like, shape=[n_samples, n_features]
Input features matrix.
ntree_limit : int
Limit number of trees in the prediction; defaults to 0 (use all trees).
Returns
-------
X_leaves : array_like, shape=[n_samples, n_trees]
For each datapoint x in X and for each tree, return the index of the
leaf x ends up in. Leaves are numbered within
``[0; 2**(self.max_depth+1))``, possibly with gaps in the numbering.
"""
test_dmatrix = DMatrix(X, missing=self.missing, nthread=self.n_jobs)
return self.get_booster().predict(test_dmatrix,
pred_leaf=True,
ntree_limit=ntree_limit)
|
[
"def",
"apply",
"(",
"self",
",",
"X",
",",
"ntree_limit",
"=",
"0",
")",
":",
"test_dmatrix",
"=",
"DMatrix",
"(",
"X",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"return",
"self",
".",
"get_booster",
"(",
")",
".",
"predict",
"(",
"test_dmatrix",
",",
"pred_leaf",
"=",
"True",
",",
"ntree_limit",
"=",
"ntree_limit",
")"
] |
Return the predicted leaf every tree for each sample.
Parameters
----------
X : array_like, shape=[n_samples, n_features]
Input features matrix.
ntree_limit : int
Limit number of trees in the prediction; defaults to 0 (use all trees).
Returns
-------
X_leaves : array_like, shape=[n_samples, n_trees]
For each datapoint x in X and for each tree, return the index of the
leaf x ends up in. Leaves are numbered within
``[0; 2**(self.max_depth+1))``, possibly with gaps in the numbering.
|
[
"Return",
"the",
"predicted",
"leaf",
"every",
"tree",
"for",
"each",
"sample",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L458-L479
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBModel.feature_importances_
|
def feature_importances_(self):
"""
Feature importances property
.. note:: Feature importance is defined only for tree boosters
Feature importance is only defined when the decision tree model is chosen as base
learner (`booster=gbtree`). It is not defined for other base learner types, such
as linear learners (`booster=gblinear`).
Returns
-------
feature_importances_ : array of shape ``[n_features]``
"""
if getattr(self, 'booster', None) is not None and self.booster != 'gbtree':
raise AttributeError('Feature importance is not defined for Booster type {}'
.format(self.booster))
b = self.get_booster()
score = b.get_score(importance_type=self.importance_type)
all_features = [score.get(f, 0.) for f in b.feature_names]
all_features = np.array(all_features, dtype=np.float32)
return all_features / all_features.sum()
|
python
|
def feature_importances_(self):
"""
Feature importances property
.. note:: Feature importance is defined only for tree boosters
Feature importance is only defined when the decision tree model is chosen as base
learner (`booster=gbtree`). It is not defined for other base learner types, such
as linear learners (`booster=gblinear`).
Returns
-------
feature_importances_ : array of shape ``[n_features]``
"""
if getattr(self, 'booster', None) is not None and self.booster != 'gbtree':
raise AttributeError('Feature importance is not defined for Booster type {}'
.format(self.booster))
b = self.get_booster()
score = b.get_score(importance_type=self.importance_type)
all_features = [score.get(f, 0.) for f in b.feature_names]
all_features = np.array(all_features, dtype=np.float32)
return all_features / all_features.sum()
|
[
"def",
"feature_importances_",
"(",
"self",
")",
":",
"if",
"getattr",
"(",
"self",
",",
"'booster'",
",",
"None",
")",
"is",
"not",
"None",
"and",
"self",
".",
"booster",
"!=",
"'gbtree'",
":",
"raise",
"AttributeError",
"(",
"'Feature importance is not defined for Booster type {}'",
".",
"format",
"(",
"self",
".",
"booster",
")",
")",
"b",
"=",
"self",
".",
"get_booster",
"(",
")",
"score",
"=",
"b",
".",
"get_score",
"(",
"importance_type",
"=",
"self",
".",
"importance_type",
")",
"all_features",
"=",
"[",
"score",
".",
"get",
"(",
"f",
",",
"0.",
")",
"for",
"f",
"in",
"b",
".",
"feature_names",
"]",
"all_features",
"=",
"np",
".",
"array",
"(",
"all_features",
",",
"dtype",
"=",
"np",
".",
"float32",
")",
"return",
"all_features",
"/",
"all_features",
".",
"sum",
"(",
")"
] |
Feature importances property
.. note:: Feature importance is defined only for tree boosters
Feature importance is only defined when the decision tree model is chosen as base
learner (`booster=gbtree`). It is not defined for other base learner types, such
as linear learners (`booster=gblinear`).
Returns
-------
feature_importances_ : array of shape ``[n_features]``
|
[
"Feature",
"importances",
"property"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L524-L546
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBModel.coef_
|
def coef_(self):
"""
Coefficients property
.. note:: Coefficients are defined only for linear learners
Coefficients are only defined when the linear model is chosen as base
learner (`booster=gblinear`). It is not defined for other base learner types, such
as tree learners (`booster=gbtree`).
Returns
-------
coef_ : array of shape ``[n_features]`` or ``[n_classes, n_features]``
"""
if getattr(self, 'booster', None) is not None and self.booster != 'gblinear':
raise AttributeError('Coefficients are not defined for Booster type {}'
.format(self.booster))
b = self.get_booster()
coef = np.array(json.loads(b.get_dump(dump_format='json')[0])['weight'])
# Logic for multiclass classification
n_classes = getattr(self, 'n_classes_', None)
if n_classes is not None:
if n_classes > 2:
assert len(coef.shape) == 1
assert coef.shape[0] % n_classes == 0
coef = coef.reshape((n_classes, -1))
return coef
|
python
|
def coef_(self):
"""
Coefficients property
.. note:: Coefficients are defined only for linear learners
Coefficients are only defined when the linear model is chosen as base
learner (`booster=gblinear`). It is not defined for other base learner types, such
as tree learners (`booster=gbtree`).
Returns
-------
coef_ : array of shape ``[n_features]`` or ``[n_classes, n_features]``
"""
if getattr(self, 'booster', None) is not None and self.booster != 'gblinear':
raise AttributeError('Coefficients are not defined for Booster type {}'
.format(self.booster))
b = self.get_booster()
coef = np.array(json.loads(b.get_dump(dump_format='json')[0])['weight'])
# Logic for multiclass classification
n_classes = getattr(self, 'n_classes_', None)
if n_classes is not None:
if n_classes > 2:
assert len(coef.shape) == 1
assert coef.shape[0] % n_classes == 0
coef = coef.reshape((n_classes, -1))
return coef
|
[
"def",
"coef_",
"(",
"self",
")",
":",
"if",
"getattr",
"(",
"self",
",",
"'booster'",
",",
"None",
")",
"is",
"not",
"None",
"and",
"self",
".",
"booster",
"!=",
"'gblinear'",
":",
"raise",
"AttributeError",
"(",
"'Coefficients are not defined for Booster type {}'",
".",
"format",
"(",
"self",
".",
"booster",
")",
")",
"b",
"=",
"self",
".",
"get_booster",
"(",
")",
"coef",
"=",
"np",
".",
"array",
"(",
"json",
".",
"loads",
"(",
"b",
".",
"get_dump",
"(",
"dump_format",
"=",
"'json'",
")",
"[",
"0",
"]",
")",
"[",
"'weight'",
"]",
")",
"# Logic for multiclass classification",
"n_classes",
"=",
"getattr",
"(",
"self",
",",
"'n_classes_'",
",",
"None",
")",
"if",
"n_classes",
"is",
"not",
"None",
":",
"if",
"n_classes",
">",
"2",
":",
"assert",
"len",
"(",
"coef",
".",
"shape",
")",
"==",
"1",
"assert",
"coef",
".",
"shape",
"[",
"0",
"]",
"%",
"n_classes",
"==",
"0",
"coef",
"=",
"coef",
".",
"reshape",
"(",
"(",
"n_classes",
",",
"-",
"1",
")",
")",
"return",
"coef"
] |
Coefficients property
.. note:: Coefficients are defined only for linear learners
Coefficients are only defined when the linear model is chosen as base
learner (`booster=gblinear`). It is not defined for other base learner types, such
as tree learners (`booster=gbtree`).
Returns
-------
coef_ : array of shape ``[n_features]`` or ``[n_classes, n_features]``
|
[
"Coefficients",
"property"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L549-L575
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBModel.intercept_
|
def intercept_(self):
"""
Intercept (bias) property
.. note:: Intercept is defined only for linear learners
Intercept (bias) is only defined when the linear model is chosen as base
learner (`booster=gblinear`). It is not defined for other base learner types, such
as tree learners (`booster=gbtree`).
Returns
-------
intercept_ : array of shape ``(1,)`` or ``[n_classes]``
"""
if getattr(self, 'booster', None) is not None and self.booster != 'gblinear':
raise AttributeError('Intercept (bias) is not defined for Booster type {}'
.format(self.booster))
b = self.get_booster()
return np.array(json.loads(b.get_dump(dump_format='json')[0])['bias'])
|
python
|
def intercept_(self):
"""
Intercept (bias) property
.. note:: Intercept is defined only for linear learners
Intercept (bias) is only defined when the linear model is chosen as base
learner (`booster=gblinear`). It is not defined for other base learner types, such
as tree learners (`booster=gbtree`).
Returns
-------
intercept_ : array of shape ``(1,)`` or ``[n_classes]``
"""
if getattr(self, 'booster', None) is not None and self.booster != 'gblinear':
raise AttributeError('Intercept (bias) is not defined for Booster type {}'
.format(self.booster))
b = self.get_booster()
return np.array(json.loads(b.get_dump(dump_format='json')[0])['bias'])
|
[
"def",
"intercept_",
"(",
"self",
")",
":",
"if",
"getattr",
"(",
"self",
",",
"'booster'",
",",
"None",
")",
"is",
"not",
"None",
"and",
"self",
".",
"booster",
"!=",
"'gblinear'",
":",
"raise",
"AttributeError",
"(",
"'Intercept (bias) is not defined for Booster type {}'",
".",
"format",
"(",
"self",
".",
"booster",
")",
")",
"b",
"=",
"self",
".",
"get_booster",
"(",
")",
"return",
"np",
".",
"array",
"(",
"json",
".",
"loads",
"(",
"b",
".",
"get_dump",
"(",
"dump_format",
"=",
"'json'",
")",
"[",
"0",
"]",
")",
"[",
"'bias'",
"]",
")"
] |
Intercept (bias) property
.. note:: Intercept is defined only for linear learners
Intercept (bias) is only defined when the linear model is chosen as base
learner (`booster=gblinear`). It is not defined for other base learner types, such
as tree learners (`booster=gbtree`).
Returns
-------
intercept_ : array of shape ``(1,)`` or ``[n_classes]``
|
[
"Intercept",
"(",
"bias",
")",
"property"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L578-L596
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBClassifier.fit
|
def fit(self, X, y, sample_weight=None, eval_set=None, eval_metric=None,
early_stopping_rounds=None, verbose=True, xgb_model=None,
sample_weight_eval_set=None, callbacks=None):
# pylint: disable = attribute-defined-outside-init,arguments-differ
"""
Fit gradient boosting classifier
Parameters
----------
X : array_like
Feature matrix
y : array_like
Labels
sample_weight : array_like
Weight for each instance
eval_set : list, optional
A list of (X, y) pairs to use as a validation set for
early-stopping
sample_weight_eval_set : list, optional
A list of the form [L_1, L_2, ..., L_n], where each L_i is a list of
instance weights on the i-th validation set.
eval_metric : str, callable, optional
If a str, should be a built-in evaluation metric to use. See
doc/parameter.rst. If callable, a custom evaluation metric. The call
signature is func(y_predicted, y_true) where y_true will be a
DMatrix object such that you may need to call the get_label
method. It must return a str, value pair where the str is a name
for the evaluation and value is the value of the evaluation
function. This objective is always minimized.
early_stopping_rounds : int, optional
Activates early stopping. Validation error needs to decrease at
least every <early_stopping_rounds> round(s) to continue training.
Requires at least one item in evals. If there's more than one,
will use the last. If early stopping occurs, the model will have
three additional fields: bst.best_score, bst.best_iteration and
bst.best_ntree_limit (bst.best_ntree_limit is the ntree_limit parameter
default value in predict method if not any other value is specified).
(Use bst.best_ntree_limit to get the correct value if num_parallel_tree
and/or num_class appears in the parameters)
verbose : bool
If `verbose` and an evaluation set is used, writes the evaluation
metric measured on the validation set to stderr.
xgb_model : str
file name of stored xgb model or 'Booster' instance Xgb model to be
loaded before training (allows training continuation).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using :ref:`callback_api`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
"""
evals_result = {}
self.classes_ = np.unique(y)
self.n_classes_ = len(self.classes_)
xgb_options = self.get_xgb_params()
if callable(self.objective):
obj = _objective_decorator(self.objective)
# Use default value. Is it really not used ?
xgb_options["objective"] = "binary:logistic"
else:
obj = None
if self.n_classes_ > 2:
# Switch to using a multiclass objective in the underlying XGB instance
xgb_options["objective"] = "multi:softprob"
xgb_options['num_class'] = self.n_classes_
feval = eval_metric if callable(eval_metric) else None
if eval_metric is not None:
if callable(eval_metric):
eval_metric = None
else:
xgb_options.update({"eval_metric": eval_metric})
self._le = XGBLabelEncoder().fit(y)
training_labels = self._le.transform(y)
if eval_set is not None:
if sample_weight_eval_set is None:
sample_weight_eval_set = [None] * len(eval_set)
evals = list(
DMatrix(eval_set[i][0], label=self._le.transform(eval_set[i][1]),
missing=self.missing, weight=sample_weight_eval_set[i],
nthread=self.n_jobs)
for i in range(len(eval_set))
)
nevals = len(evals)
eval_names = ["validation_{}".format(i) for i in range(nevals)]
evals = list(zip(evals, eval_names))
else:
evals = ()
self._features_count = X.shape[1]
if sample_weight is not None:
train_dmatrix = DMatrix(X, label=training_labels, weight=sample_weight,
missing=self.missing, nthread=self.n_jobs)
else:
train_dmatrix = DMatrix(X, label=training_labels,
missing=self.missing, nthread=self.n_jobs)
self._Booster = train(xgb_options, train_dmatrix, self.get_num_boosting_rounds(),
evals=evals, early_stopping_rounds=early_stopping_rounds,
evals_result=evals_result, obj=obj, feval=feval,
verbose_eval=verbose, xgb_model=xgb_model,
callbacks=callbacks)
self.objective = xgb_options["objective"]
if evals_result:
for val in evals_result.items():
evals_result_key = list(val[1].keys())[0]
evals_result[val[0]][evals_result_key] = val[1][evals_result_key]
self.evals_result_ = evals_result
if early_stopping_rounds is not None:
self.best_score = self._Booster.best_score
self.best_iteration = self._Booster.best_iteration
self.best_ntree_limit = self._Booster.best_ntree_limit
return self
|
python
|
def fit(self, X, y, sample_weight=None, eval_set=None, eval_metric=None,
early_stopping_rounds=None, verbose=True, xgb_model=None,
sample_weight_eval_set=None, callbacks=None):
# pylint: disable = attribute-defined-outside-init,arguments-differ
"""
Fit gradient boosting classifier
Parameters
----------
X : array_like
Feature matrix
y : array_like
Labels
sample_weight : array_like
Weight for each instance
eval_set : list, optional
A list of (X, y) pairs to use as a validation set for
early-stopping
sample_weight_eval_set : list, optional
A list of the form [L_1, L_2, ..., L_n], where each L_i is a list of
instance weights on the i-th validation set.
eval_metric : str, callable, optional
If a str, should be a built-in evaluation metric to use. See
doc/parameter.rst. If callable, a custom evaluation metric. The call
signature is func(y_predicted, y_true) where y_true will be a
DMatrix object such that you may need to call the get_label
method. It must return a str, value pair where the str is a name
for the evaluation and value is the value of the evaluation
function. This objective is always minimized.
early_stopping_rounds : int, optional
Activates early stopping. Validation error needs to decrease at
least every <early_stopping_rounds> round(s) to continue training.
Requires at least one item in evals. If there's more than one,
will use the last. If early stopping occurs, the model will have
three additional fields: bst.best_score, bst.best_iteration and
bst.best_ntree_limit (bst.best_ntree_limit is the ntree_limit parameter
default value in predict method if not any other value is specified).
(Use bst.best_ntree_limit to get the correct value if num_parallel_tree
and/or num_class appears in the parameters)
verbose : bool
If `verbose` and an evaluation set is used, writes the evaluation
metric measured on the validation set to stderr.
xgb_model : str
file name of stored xgb model or 'Booster' instance Xgb model to be
loaded before training (allows training continuation).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using :ref:`callback_api`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
"""
evals_result = {}
self.classes_ = np.unique(y)
self.n_classes_ = len(self.classes_)
xgb_options = self.get_xgb_params()
if callable(self.objective):
obj = _objective_decorator(self.objective)
# Use default value. Is it really not used ?
xgb_options["objective"] = "binary:logistic"
else:
obj = None
if self.n_classes_ > 2:
# Switch to using a multiclass objective in the underlying XGB instance
xgb_options["objective"] = "multi:softprob"
xgb_options['num_class'] = self.n_classes_
feval = eval_metric if callable(eval_metric) else None
if eval_metric is not None:
if callable(eval_metric):
eval_metric = None
else:
xgb_options.update({"eval_metric": eval_metric})
self._le = XGBLabelEncoder().fit(y)
training_labels = self._le.transform(y)
if eval_set is not None:
if sample_weight_eval_set is None:
sample_weight_eval_set = [None] * len(eval_set)
evals = list(
DMatrix(eval_set[i][0], label=self._le.transform(eval_set[i][1]),
missing=self.missing, weight=sample_weight_eval_set[i],
nthread=self.n_jobs)
for i in range(len(eval_set))
)
nevals = len(evals)
eval_names = ["validation_{}".format(i) for i in range(nevals)]
evals = list(zip(evals, eval_names))
else:
evals = ()
self._features_count = X.shape[1]
if sample_weight is not None:
train_dmatrix = DMatrix(X, label=training_labels, weight=sample_weight,
missing=self.missing, nthread=self.n_jobs)
else:
train_dmatrix = DMatrix(X, label=training_labels,
missing=self.missing, nthread=self.n_jobs)
self._Booster = train(xgb_options, train_dmatrix, self.get_num_boosting_rounds(),
evals=evals, early_stopping_rounds=early_stopping_rounds,
evals_result=evals_result, obj=obj, feval=feval,
verbose_eval=verbose, xgb_model=xgb_model,
callbacks=callbacks)
self.objective = xgb_options["objective"]
if evals_result:
for val in evals_result.items():
evals_result_key = list(val[1].keys())[0]
evals_result[val[0]][evals_result_key] = val[1][evals_result_key]
self.evals_result_ = evals_result
if early_stopping_rounds is not None:
self.best_score = self._Booster.best_score
self.best_iteration = self._Booster.best_iteration
self.best_ntree_limit = self._Booster.best_ntree_limit
return self
|
[
"def",
"fit",
"(",
"self",
",",
"X",
",",
"y",
",",
"sample_weight",
"=",
"None",
",",
"eval_set",
"=",
"None",
",",
"eval_metric",
"=",
"None",
",",
"early_stopping_rounds",
"=",
"None",
",",
"verbose",
"=",
"True",
",",
"xgb_model",
"=",
"None",
",",
"sample_weight_eval_set",
"=",
"None",
",",
"callbacks",
"=",
"None",
")",
":",
"# pylint: disable = attribute-defined-outside-init,arguments-differ",
"evals_result",
"=",
"{",
"}",
"self",
".",
"classes_",
"=",
"np",
".",
"unique",
"(",
"y",
")",
"self",
".",
"n_classes_",
"=",
"len",
"(",
"self",
".",
"classes_",
")",
"xgb_options",
"=",
"self",
".",
"get_xgb_params",
"(",
")",
"if",
"callable",
"(",
"self",
".",
"objective",
")",
":",
"obj",
"=",
"_objective_decorator",
"(",
"self",
".",
"objective",
")",
"# Use default value. Is it really not used ?",
"xgb_options",
"[",
"\"objective\"",
"]",
"=",
"\"binary:logistic\"",
"else",
":",
"obj",
"=",
"None",
"if",
"self",
".",
"n_classes_",
">",
"2",
":",
"# Switch to using a multiclass objective in the underlying XGB instance",
"xgb_options",
"[",
"\"objective\"",
"]",
"=",
"\"multi:softprob\"",
"xgb_options",
"[",
"'num_class'",
"]",
"=",
"self",
".",
"n_classes_",
"feval",
"=",
"eval_metric",
"if",
"callable",
"(",
"eval_metric",
")",
"else",
"None",
"if",
"eval_metric",
"is",
"not",
"None",
":",
"if",
"callable",
"(",
"eval_metric",
")",
":",
"eval_metric",
"=",
"None",
"else",
":",
"xgb_options",
".",
"update",
"(",
"{",
"\"eval_metric\"",
":",
"eval_metric",
"}",
")",
"self",
".",
"_le",
"=",
"XGBLabelEncoder",
"(",
")",
".",
"fit",
"(",
"y",
")",
"training_labels",
"=",
"self",
".",
"_le",
".",
"transform",
"(",
"y",
")",
"if",
"eval_set",
"is",
"not",
"None",
":",
"if",
"sample_weight_eval_set",
"is",
"None",
":",
"sample_weight_eval_set",
"=",
"[",
"None",
"]",
"*",
"len",
"(",
"eval_set",
")",
"evals",
"=",
"list",
"(",
"DMatrix",
"(",
"eval_set",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"label",
"=",
"self",
".",
"_le",
".",
"transform",
"(",
"eval_set",
"[",
"i",
"]",
"[",
"1",
"]",
")",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"weight",
"=",
"sample_weight_eval_set",
"[",
"i",
"]",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"eval_set",
")",
")",
")",
"nevals",
"=",
"len",
"(",
"evals",
")",
"eval_names",
"=",
"[",
"\"validation_{}\"",
".",
"format",
"(",
"i",
")",
"for",
"i",
"in",
"range",
"(",
"nevals",
")",
"]",
"evals",
"=",
"list",
"(",
"zip",
"(",
"evals",
",",
"eval_names",
")",
")",
"else",
":",
"evals",
"=",
"(",
")",
"self",
".",
"_features_count",
"=",
"X",
".",
"shape",
"[",
"1",
"]",
"if",
"sample_weight",
"is",
"not",
"None",
":",
"train_dmatrix",
"=",
"DMatrix",
"(",
"X",
",",
"label",
"=",
"training_labels",
",",
"weight",
"=",
"sample_weight",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"else",
":",
"train_dmatrix",
"=",
"DMatrix",
"(",
"X",
",",
"label",
"=",
"training_labels",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"self",
".",
"_Booster",
"=",
"train",
"(",
"xgb_options",
",",
"train_dmatrix",
",",
"self",
".",
"get_num_boosting_rounds",
"(",
")",
",",
"evals",
"=",
"evals",
",",
"early_stopping_rounds",
"=",
"early_stopping_rounds",
",",
"evals_result",
"=",
"evals_result",
",",
"obj",
"=",
"obj",
",",
"feval",
"=",
"feval",
",",
"verbose_eval",
"=",
"verbose",
",",
"xgb_model",
"=",
"xgb_model",
",",
"callbacks",
"=",
"callbacks",
")",
"self",
".",
"objective",
"=",
"xgb_options",
"[",
"\"objective\"",
"]",
"if",
"evals_result",
":",
"for",
"val",
"in",
"evals_result",
".",
"items",
"(",
")",
":",
"evals_result_key",
"=",
"list",
"(",
"val",
"[",
"1",
"]",
".",
"keys",
"(",
")",
")",
"[",
"0",
"]",
"evals_result",
"[",
"val",
"[",
"0",
"]",
"]",
"[",
"evals_result_key",
"]",
"=",
"val",
"[",
"1",
"]",
"[",
"evals_result_key",
"]",
"self",
".",
"evals_result_",
"=",
"evals_result",
"if",
"early_stopping_rounds",
"is",
"not",
"None",
":",
"self",
".",
"best_score",
"=",
"self",
".",
"_Booster",
".",
"best_score",
"self",
".",
"best_iteration",
"=",
"self",
".",
"_Booster",
".",
"best_iteration",
"self",
".",
"best_ntree_limit",
"=",
"self",
".",
"_Booster",
".",
"best_ntree_limit",
"return",
"self"
] |
Fit gradient boosting classifier
Parameters
----------
X : array_like
Feature matrix
y : array_like
Labels
sample_weight : array_like
Weight for each instance
eval_set : list, optional
A list of (X, y) pairs to use as a validation set for
early-stopping
sample_weight_eval_set : list, optional
A list of the form [L_1, L_2, ..., L_n], where each L_i is a list of
instance weights on the i-th validation set.
eval_metric : str, callable, optional
If a str, should be a built-in evaluation metric to use. See
doc/parameter.rst. If callable, a custom evaluation metric. The call
signature is func(y_predicted, y_true) where y_true will be a
DMatrix object such that you may need to call the get_label
method. It must return a str, value pair where the str is a name
for the evaluation and value is the value of the evaluation
function. This objective is always minimized.
early_stopping_rounds : int, optional
Activates early stopping. Validation error needs to decrease at
least every <early_stopping_rounds> round(s) to continue training.
Requires at least one item in evals. If there's more than one,
will use the last. If early stopping occurs, the model will have
three additional fields: bst.best_score, bst.best_iteration and
bst.best_ntree_limit (bst.best_ntree_limit is the ntree_limit parameter
default value in predict method if not any other value is specified).
(Use bst.best_ntree_limit to get the correct value if num_parallel_tree
and/or num_class appears in the parameters)
verbose : bool
If `verbose` and an evaluation set is used, writes the evaluation
metric measured on the validation set to stderr.
xgb_model : str
file name of stored xgb model or 'Booster' instance Xgb model to be
loaded before training (allows training continuation).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using :ref:`callback_api`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
|
[
"Fit",
"gradient",
"boosting",
"classifier"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L622-L746
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBClassifier.predict
|
def predict(self, data, output_margin=False, ntree_limit=None, validate_features=True):
"""
Predict with `data`.
.. note:: This function is not thread safe.
For each booster object, predict can only be called from one thread.
If you want to run prediction using multiple thread, call ``xgb.copy()`` to make copies
of model object and then call ``predict()``.
.. note:: Using ``predict()`` with DART booster
If the booster object is DART type, ``predict()`` will perform dropouts, i.e. only
some of the trees will be evaluated. This will produce incorrect results if ``data`` is
not the training data. To obtain correct results on test sets, set ``ntree_limit`` to
a nonzero value, e.g.
.. code-block:: python
preds = bst.predict(dtest, ntree_limit=num_round)
Parameters
----------
data : DMatrix
The dmatrix storing the input.
output_margin : bool
Whether to output the raw untransformed margin value.
ntree_limit : int
Limit number of trees in the prediction; defaults to best_ntree_limit if defined
(i.e. it has been trained with early stopping), otherwise 0 (use all trees).
validate_features : bool
When this is True, validate that the Booster's and data's feature_names are identical.
Otherwise, it is assumed that the feature_names are the same.
Returns
-------
prediction : numpy array
"""
test_dmatrix = DMatrix(data, missing=self.missing, nthread=self.n_jobs)
if ntree_limit is None:
ntree_limit = getattr(self, "best_ntree_limit", 0)
class_probs = self.get_booster().predict(test_dmatrix,
output_margin=output_margin,
ntree_limit=ntree_limit,
validate_features=validate_features)
if output_margin:
# If output_margin is active, simply return the scores
return class_probs
if len(class_probs.shape) > 1:
column_indexes = np.argmax(class_probs, axis=1)
else:
column_indexes = np.repeat(0, class_probs.shape[0])
column_indexes[class_probs > 0.5] = 1
return self._le.inverse_transform(column_indexes)
|
python
|
def predict(self, data, output_margin=False, ntree_limit=None, validate_features=True):
"""
Predict with `data`.
.. note:: This function is not thread safe.
For each booster object, predict can only be called from one thread.
If you want to run prediction using multiple thread, call ``xgb.copy()`` to make copies
of model object and then call ``predict()``.
.. note:: Using ``predict()`` with DART booster
If the booster object is DART type, ``predict()`` will perform dropouts, i.e. only
some of the trees will be evaluated. This will produce incorrect results if ``data`` is
not the training data. To obtain correct results on test sets, set ``ntree_limit`` to
a nonzero value, e.g.
.. code-block:: python
preds = bst.predict(dtest, ntree_limit=num_round)
Parameters
----------
data : DMatrix
The dmatrix storing the input.
output_margin : bool
Whether to output the raw untransformed margin value.
ntree_limit : int
Limit number of trees in the prediction; defaults to best_ntree_limit if defined
(i.e. it has been trained with early stopping), otherwise 0 (use all trees).
validate_features : bool
When this is True, validate that the Booster's and data's feature_names are identical.
Otherwise, it is assumed that the feature_names are the same.
Returns
-------
prediction : numpy array
"""
test_dmatrix = DMatrix(data, missing=self.missing, nthread=self.n_jobs)
if ntree_limit is None:
ntree_limit = getattr(self, "best_ntree_limit", 0)
class_probs = self.get_booster().predict(test_dmatrix,
output_margin=output_margin,
ntree_limit=ntree_limit,
validate_features=validate_features)
if output_margin:
# If output_margin is active, simply return the scores
return class_probs
if len(class_probs.shape) > 1:
column_indexes = np.argmax(class_probs, axis=1)
else:
column_indexes = np.repeat(0, class_probs.shape[0])
column_indexes[class_probs > 0.5] = 1
return self._le.inverse_transform(column_indexes)
|
[
"def",
"predict",
"(",
"self",
",",
"data",
",",
"output_margin",
"=",
"False",
",",
"ntree_limit",
"=",
"None",
",",
"validate_features",
"=",
"True",
")",
":",
"test_dmatrix",
"=",
"DMatrix",
"(",
"data",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"if",
"ntree_limit",
"is",
"None",
":",
"ntree_limit",
"=",
"getattr",
"(",
"self",
",",
"\"best_ntree_limit\"",
",",
"0",
")",
"class_probs",
"=",
"self",
".",
"get_booster",
"(",
")",
".",
"predict",
"(",
"test_dmatrix",
",",
"output_margin",
"=",
"output_margin",
",",
"ntree_limit",
"=",
"ntree_limit",
",",
"validate_features",
"=",
"validate_features",
")",
"if",
"output_margin",
":",
"# If output_margin is active, simply return the scores",
"return",
"class_probs",
"if",
"len",
"(",
"class_probs",
".",
"shape",
")",
">",
"1",
":",
"column_indexes",
"=",
"np",
".",
"argmax",
"(",
"class_probs",
",",
"axis",
"=",
"1",
")",
"else",
":",
"column_indexes",
"=",
"np",
".",
"repeat",
"(",
"0",
",",
"class_probs",
".",
"shape",
"[",
"0",
"]",
")",
"column_indexes",
"[",
"class_probs",
">",
"0.5",
"]",
"=",
"1",
"return",
"self",
".",
"_le",
".",
"inverse_transform",
"(",
"column_indexes",
")"
] |
Predict with `data`.
.. note:: This function is not thread safe.
For each booster object, predict can only be called from one thread.
If you want to run prediction using multiple thread, call ``xgb.copy()`` to make copies
of model object and then call ``predict()``.
.. note:: Using ``predict()`` with DART booster
If the booster object is DART type, ``predict()`` will perform dropouts, i.e. only
some of the trees will be evaluated. This will produce incorrect results if ``data`` is
not the training data. To obtain correct results on test sets, set ``ntree_limit`` to
a nonzero value, e.g.
.. code-block:: python
preds = bst.predict(dtest, ntree_limit=num_round)
Parameters
----------
data : DMatrix
The dmatrix storing the input.
output_margin : bool
Whether to output the raw untransformed margin value.
ntree_limit : int
Limit number of trees in the prediction; defaults to best_ntree_limit if defined
(i.e. it has been trained with early stopping), otherwise 0 (use all trees).
validate_features : bool
When this is True, validate that the Booster's and data's feature_names are identical.
Otherwise, it is assumed that the feature_names are the same.
Returns
-------
prediction : numpy array
|
[
"Predict",
"with",
"data",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L748-L801
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBClassifier.predict_proba
|
def predict_proba(self, data, ntree_limit=None, validate_features=True):
"""
Predict the probability of each `data` example being of a given class.
.. note:: This function is not thread safe
For each booster object, predict can only be called from one thread.
If you want to run prediction using multiple thread, call ``xgb.copy()`` to make copies
of model object and then call predict
Parameters
----------
data : DMatrix
The dmatrix storing the input.
ntree_limit : int
Limit number of trees in the prediction; defaults to best_ntree_limit if defined
(i.e. it has been trained with early stopping), otherwise 0 (use all trees).
validate_features : bool
When this is True, validate that the Booster's and data's feature_names are identical.
Otherwise, it is assumed that the feature_names are the same.
Returns
-------
prediction : numpy array
a numpy array with the probability of each data example being of a given class.
"""
test_dmatrix = DMatrix(data, missing=self.missing, nthread=self.n_jobs)
if ntree_limit is None:
ntree_limit = getattr(self, "best_ntree_limit", 0)
class_probs = self.get_booster().predict(test_dmatrix,
ntree_limit=ntree_limit,
validate_features=validate_features)
if self.objective == "multi:softprob":
return class_probs
classone_probs = class_probs
classzero_probs = 1.0 - classone_probs
return np.vstack((classzero_probs, classone_probs)).transpose()
|
python
|
def predict_proba(self, data, ntree_limit=None, validate_features=True):
"""
Predict the probability of each `data` example being of a given class.
.. note:: This function is not thread safe
For each booster object, predict can only be called from one thread.
If you want to run prediction using multiple thread, call ``xgb.copy()`` to make copies
of model object and then call predict
Parameters
----------
data : DMatrix
The dmatrix storing the input.
ntree_limit : int
Limit number of trees in the prediction; defaults to best_ntree_limit if defined
(i.e. it has been trained with early stopping), otherwise 0 (use all trees).
validate_features : bool
When this is True, validate that the Booster's and data's feature_names are identical.
Otherwise, it is assumed that the feature_names are the same.
Returns
-------
prediction : numpy array
a numpy array with the probability of each data example being of a given class.
"""
test_dmatrix = DMatrix(data, missing=self.missing, nthread=self.n_jobs)
if ntree_limit is None:
ntree_limit = getattr(self, "best_ntree_limit", 0)
class_probs = self.get_booster().predict(test_dmatrix,
ntree_limit=ntree_limit,
validate_features=validate_features)
if self.objective == "multi:softprob":
return class_probs
classone_probs = class_probs
classzero_probs = 1.0 - classone_probs
return np.vstack((classzero_probs, classone_probs)).transpose()
|
[
"def",
"predict_proba",
"(",
"self",
",",
"data",
",",
"ntree_limit",
"=",
"None",
",",
"validate_features",
"=",
"True",
")",
":",
"test_dmatrix",
"=",
"DMatrix",
"(",
"data",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"if",
"ntree_limit",
"is",
"None",
":",
"ntree_limit",
"=",
"getattr",
"(",
"self",
",",
"\"best_ntree_limit\"",
",",
"0",
")",
"class_probs",
"=",
"self",
".",
"get_booster",
"(",
")",
".",
"predict",
"(",
"test_dmatrix",
",",
"ntree_limit",
"=",
"ntree_limit",
",",
"validate_features",
"=",
"validate_features",
")",
"if",
"self",
".",
"objective",
"==",
"\"multi:softprob\"",
":",
"return",
"class_probs",
"classone_probs",
"=",
"class_probs",
"classzero_probs",
"=",
"1.0",
"-",
"classone_probs",
"return",
"np",
".",
"vstack",
"(",
"(",
"classzero_probs",
",",
"classone_probs",
")",
")",
".",
"transpose",
"(",
")"
] |
Predict the probability of each `data` example being of a given class.
.. note:: This function is not thread safe
For each booster object, predict can only be called from one thread.
If you want to run prediction using multiple thread, call ``xgb.copy()`` to make copies
of model object and then call predict
Parameters
----------
data : DMatrix
The dmatrix storing the input.
ntree_limit : int
Limit number of trees in the prediction; defaults to best_ntree_limit if defined
(i.e. it has been trained with early stopping), otherwise 0 (use all trees).
validate_features : bool
When this is True, validate that the Booster's and data's feature_names are identical.
Otherwise, it is assumed that the feature_names are the same.
Returns
-------
prediction : numpy array
a numpy array with the probability of each data example being of a given class.
|
[
"Predict",
"the",
"probability",
"of",
"each",
"data",
"example",
"being",
"of",
"a",
"given",
"class",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L803-L839
|
train
|
dmlc/xgboost
|
python-package/xgboost/sklearn.py
|
XGBRanker.fit
|
def fit(self, X, y, group, sample_weight=None, eval_set=None, sample_weight_eval_set=None,
eval_group=None, eval_metric=None, early_stopping_rounds=None,
verbose=False, xgb_model=None, callbacks=None):
# pylint: disable = attribute-defined-outside-init,arguments-differ
"""
Fit the gradient boosting model
Parameters
----------
X : array_like
Feature matrix
y : array_like
Labels
group : array_like
group size of training data
sample_weight : array_like
group weights
.. note:: Weights are per-group for ranking tasks
In ranking task, one weight is assigned to each group (not each data
point). This is because we only care about the relative ordering of
data points within each group, so it doesn't make sense to assign
weights to individual data points.
eval_set : list, optional
A list of (X, y) tuple pairs to use as a validation set for
early-stopping
sample_weight_eval_set : list, optional
A list of the form [L_1, L_2, ..., L_n], where each L_i is a list of
group weights on the i-th validation set.
.. note:: Weights are per-group for ranking tasks
In ranking task, one weight is assigned to each group (not each data
point). This is because we only care about the relative ordering of
data points within each group, so it doesn't make sense to assign
weights to individual data points.
eval_group : list of arrays, optional
A list that contains the group size corresponds to each
(X, y) pair in eval_set
eval_metric : str, callable, optional
If a str, should be a built-in evaluation metric to use. See
doc/parameter.rst. If callable, a custom evaluation metric. The call
signature is func(y_predicted, y_true) where y_true will be a
DMatrix object such that you may need to call the get_label
method. It must return a str, value pair where the str is a name
for the evaluation and value is the value of the evaluation
function. This objective is always minimized.
early_stopping_rounds : int
Activates early stopping. Validation error needs to decrease at
least every <early_stopping_rounds> round(s) to continue training.
Requires at least one item in evals. If there's more than one,
will use the last. Returns the model from the last iteration
(not the best one). If early stopping occurs, the model will
have three additional fields: bst.best_score, bst.best_iteration
and bst.best_ntree_limit.
(Use bst.best_ntree_limit to get the correct value if num_parallel_tree
and/or num_class appears in the parameters)
verbose : bool
If `verbose` and an evaluation set is used, writes the evaluation
metric measured on the validation set to stderr.
xgb_model : str
file name of stored xgb model or 'Booster' instance Xgb model to be
loaded before training (allows training continuation).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using :ref:`callback_api`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
"""
# check if group information is provided
if group is None:
raise ValueError("group is required for ranking task")
if eval_set is not None:
if eval_group is None:
raise ValueError("eval_group is required if eval_set is not None")
if len(eval_group) != len(eval_set):
raise ValueError("length of eval_group should match that of eval_set")
if any(group is None for group in eval_group):
raise ValueError("group is required for all eval datasets for ranking task")
def _dmat_init(group, **params):
ret = DMatrix(**params)
ret.set_group(group)
return ret
if sample_weight is not None:
train_dmatrix = _dmat_init(group, data=X, label=y, weight=sample_weight,
missing=self.missing, nthread=self.n_jobs)
else:
train_dmatrix = _dmat_init(group, data=X, label=y,
missing=self.missing, nthread=self.n_jobs)
evals_result = {}
if eval_set is not None:
if sample_weight_eval_set is None:
sample_weight_eval_set = [None] * len(eval_set)
evals = [_dmat_init(eval_group[i], data=eval_set[i][0], label=eval_set[i][1],
missing=self.missing, weight=sample_weight_eval_set[i],
nthread=self.n_jobs) for i in range(len(eval_set))]
nevals = len(evals)
eval_names = ["eval_{}".format(i) for i in range(nevals)]
evals = list(zip(evals, eval_names))
else:
evals = ()
params = self.get_xgb_params()
feval = eval_metric if callable(eval_metric) else None
if eval_metric is not None:
if callable(eval_metric):
eval_metric = None
else:
params.update({'eval_metric': eval_metric})
self._Booster = train(params, train_dmatrix,
self.n_estimators,
early_stopping_rounds=early_stopping_rounds, evals=evals,
evals_result=evals_result, feval=feval,
verbose_eval=verbose, xgb_model=xgb_model,
callbacks=callbacks)
self.objective = params["objective"]
if evals_result:
for val in evals_result.items():
evals_result_key = list(val[1].keys())[0]
evals_result[val[0]][evals_result_key] = val[1][evals_result_key]
self.evals_result = evals_result
if early_stopping_rounds is not None:
self.best_score = self._Booster.best_score
self.best_iteration = self._Booster.best_iteration
self.best_ntree_limit = self._Booster.best_ntree_limit
return self
|
python
|
def fit(self, X, y, group, sample_weight=None, eval_set=None, sample_weight_eval_set=None,
eval_group=None, eval_metric=None, early_stopping_rounds=None,
verbose=False, xgb_model=None, callbacks=None):
# pylint: disable = attribute-defined-outside-init,arguments-differ
"""
Fit the gradient boosting model
Parameters
----------
X : array_like
Feature matrix
y : array_like
Labels
group : array_like
group size of training data
sample_weight : array_like
group weights
.. note:: Weights are per-group for ranking tasks
In ranking task, one weight is assigned to each group (not each data
point). This is because we only care about the relative ordering of
data points within each group, so it doesn't make sense to assign
weights to individual data points.
eval_set : list, optional
A list of (X, y) tuple pairs to use as a validation set for
early-stopping
sample_weight_eval_set : list, optional
A list of the form [L_1, L_2, ..., L_n], where each L_i is a list of
group weights on the i-th validation set.
.. note:: Weights are per-group for ranking tasks
In ranking task, one weight is assigned to each group (not each data
point). This is because we only care about the relative ordering of
data points within each group, so it doesn't make sense to assign
weights to individual data points.
eval_group : list of arrays, optional
A list that contains the group size corresponds to each
(X, y) pair in eval_set
eval_metric : str, callable, optional
If a str, should be a built-in evaluation metric to use. See
doc/parameter.rst. If callable, a custom evaluation metric. The call
signature is func(y_predicted, y_true) where y_true will be a
DMatrix object such that you may need to call the get_label
method. It must return a str, value pair where the str is a name
for the evaluation and value is the value of the evaluation
function. This objective is always minimized.
early_stopping_rounds : int
Activates early stopping. Validation error needs to decrease at
least every <early_stopping_rounds> round(s) to continue training.
Requires at least one item in evals. If there's more than one,
will use the last. Returns the model from the last iteration
(not the best one). If early stopping occurs, the model will
have three additional fields: bst.best_score, bst.best_iteration
and bst.best_ntree_limit.
(Use bst.best_ntree_limit to get the correct value if num_parallel_tree
and/or num_class appears in the parameters)
verbose : bool
If `verbose` and an evaluation set is used, writes the evaluation
metric measured on the validation set to stderr.
xgb_model : str
file name of stored xgb model or 'Booster' instance Xgb model to be
loaded before training (allows training continuation).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using :ref:`callback_api`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
"""
# check if group information is provided
if group is None:
raise ValueError("group is required for ranking task")
if eval_set is not None:
if eval_group is None:
raise ValueError("eval_group is required if eval_set is not None")
if len(eval_group) != len(eval_set):
raise ValueError("length of eval_group should match that of eval_set")
if any(group is None for group in eval_group):
raise ValueError("group is required for all eval datasets for ranking task")
def _dmat_init(group, **params):
ret = DMatrix(**params)
ret.set_group(group)
return ret
if sample_weight is not None:
train_dmatrix = _dmat_init(group, data=X, label=y, weight=sample_weight,
missing=self.missing, nthread=self.n_jobs)
else:
train_dmatrix = _dmat_init(group, data=X, label=y,
missing=self.missing, nthread=self.n_jobs)
evals_result = {}
if eval_set is not None:
if sample_weight_eval_set is None:
sample_weight_eval_set = [None] * len(eval_set)
evals = [_dmat_init(eval_group[i], data=eval_set[i][0], label=eval_set[i][1],
missing=self.missing, weight=sample_weight_eval_set[i],
nthread=self.n_jobs) for i in range(len(eval_set))]
nevals = len(evals)
eval_names = ["eval_{}".format(i) for i in range(nevals)]
evals = list(zip(evals, eval_names))
else:
evals = ()
params = self.get_xgb_params()
feval = eval_metric if callable(eval_metric) else None
if eval_metric is not None:
if callable(eval_metric):
eval_metric = None
else:
params.update({'eval_metric': eval_metric})
self._Booster = train(params, train_dmatrix,
self.n_estimators,
early_stopping_rounds=early_stopping_rounds, evals=evals,
evals_result=evals_result, feval=feval,
verbose_eval=verbose, xgb_model=xgb_model,
callbacks=callbacks)
self.objective = params["objective"]
if evals_result:
for val in evals_result.items():
evals_result_key = list(val[1].keys())[0]
evals_result[val[0]][evals_result_key] = val[1][evals_result_key]
self.evals_result = evals_result
if early_stopping_rounds is not None:
self.best_score = self._Booster.best_score
self.best_iteration = self._Booster.best_iteration
self.best_ntree_limit = self._Booster.best_ntree_limit
return self
|
[
"def",
"fit",
"(",
"self",
",",
"X",
",",
"y",
",",
"group",
",",
"sample_weight",
"=",
"None",
",",
"eval_set",
"=",
"None",
",",
"sample_weight_eval_set",
"=",
"None",
",",
"eval_group",
"=",
"None",
",",
"eval_metric",
"=",
"None",
",",
"early_stopping_rounds",
"=",
"None",
",",
"verbose",
"=",
"False",
",",
"xgb_model",
"=",
"None",
",",
"callbacks",
"=",
"None",
")",
":",
"# pylint: disable = attribute-defined-outside-init,arguments-differ",
"# check if group information is provided",
"if",
"group",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"\"group is required for ranking task\"",
")",
"if",
"eval_set",
"is",
"not",
"None",
":",
"if",
"eval_group",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"\"eval_group is required if eval_set is not None\"",
")",
"if",
"len",
"(",
"eval_group",
")",
"!=",
"len",
"(",
"eval_set",
")",
":",
"raise",
"ValueError",
"(",
"\"length of eval_group should match that of eval_set\"",
")",
"if",
"any",
"(",
"group",
"is",
"None",
"for",
"group",
"in",
"eval_group",
")",
":",
"raise",
"ValueError",
"(",
"\"group is required for all eval datasets for ranking task\"",
")",
"def",
"_dmat_init",
"(",
"group",
",",
"*",
"*",
"params",
")",
":",
"ret",
"=",
"DMatrix",
"(",
"*",
"*",
"params",
")",
"ret",
".",
"set_group",
"(",
"group",
")",
"return",
"ret",
"if",
"sample_weight",
"is",
"not",
"None",
":",
"train_dmatrix",
"=",
"_dmat_init",
"(",
"group",
",",
"data",
"=",
"X",
",",
"label",
"=",
"y",
",",
"weight",
"=",
"sample_weight",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"else",
":",
"train_dmatrix",
"=",
"_dmat_init",
"(",
"group",
",",
"data",
"=",
"X",
",",
"label",
"=",
"y",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"evals_result",
"=",
"{",
"}",
"if",
"eval_set",
"is",
"not",
"None",
":",
"if",
"sample_weight_eval_set",
"is",
"None",
":",
"sample_weight_eval_set",
"=",
"[",
"None",
"]",
"*",
"len",
"(",
"eval_set",
")",
"evals",
"=",
"[",
"_dmat_init",
"(",
"eval_group",
"[",
"i",
"]",
",",
"data",
"=",
"eval_set",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"label",
"=",
"eval_set",
"[",
"i",
"]",
"[",
"1",
"]",
",",
"missing",
"=",
"self",
".",
"missing",
",",
"weight",
"=",
"sample_weight_eval_set",
"[",
"i",
"]",
",",
"nthread",
"=",
"self",
".",
"n_jobs",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"eval_set",
")",
")",
"]",
"nevals",
"=",
"len",
"(",
"evals",
")",
"eval_names",
"=",
"[",
"\"eval_{}\"",
".",
"format",
"(",
"i",
")",
"for",
"i",
"in",
"range",
"(",
"nevals",
")",
"]",
"evals",
"=",
"list",
"(",
"zip",
"(",
"evals",
",",
"eval_names",
")",
")",
"else",
":",
"evals",
"=",
"(",
")",
"params",
"=",
"self",
".",
"get_xgb_params",
"(",
")",
"feval",
"=",
"eval_metric",
"if",
"callable",
"(",
"eval_metric",
")",
"else",
"None",
"if",
"eval_metric",
"is",
"not",
"None",
":",
"if",
"callable",
"(",
"eval_metric",
")",
":",
"eval_metric",
"=",
"None",
"else",
":",
"params",
".",
"update",
"(",
"{",
"'eval_metric'",
":",
"eval_metric",
"}",
")",
"self",
".",
"_Booster",
"=",
"train",
"(",
"params",
",",
"train_dmatrix",
",",
"self",
".",
"n_estimators",
",",
"early_stopping_rounds",
"=",
"early_stopping_rounds",
",",
"evals",
"=",
"evals",
",",
"evals_result",
"=",
"evals_result",
",",
"feval",
"=",
"feval",
",",
"verbose_eval",
"=",
"verbose",
",",
"xgb_model",
"=",
"xgb_model",
",",
"callbacks",
"=",
"callbacks",
")",
"self",
".",
"objective",
"=",
"params",
"[",
"\"objective\"",
"]",
"if",
"evals_result",
":",
"for",
"val",
"in",
"evals_result",
".",
"items",
"(",
")",
":",
"evals_result_key",
"=",
"list",
"(",
"val",
"[",
"1",
"]",
".",
"keys",
"(",
")",
")",
"[",
"0",
"]",
"evals_result",
"[",
"val",
"[",
"0",
"]",
"]",
"[",
"evals_result_key",
"]",
"=",
"val",
"[",
"1",
"]",
"[",
"evals_result_key",
"]",
"self",
".",
"evals_result",
"=",
"evals_result",
"if",
"early_stopping_rounds",
"is",
"not",
"None",
":",
"self",
".",
"best_score",
"=",
"self",
".",
"_Booster",
".",
"best_score",
"self",
".",
"best_iteration",
"=",
"self",
".",
"_Booster",
".",
"best_iteration",
"self",
".",
"best_ntree_limit",
"=",
"self",
".",
"_Booster",
".",
"best_ntree_limit",
"return",
"self"
] |
Fit the gradient boosting model
Parameters
----------
X : array_like
Feature matrix
y : array_like
Labels
group : array_like
group size of training data
sample_weight : array_like
group weights
.. note:: Weights are per-group for ranking tasks
In ranking task, one weight is assigned to each group (not each data
point). This is because we only care about the relative ordering of
data points within each group, so it doesn't make sense to assign
weights to individual data points.
eval_set : list, optional
A list of (X, y) tuple pairs to use as a validation set for
early-stopping
sample_weight_eval_set : list, optional
A list of the form [L_1, L_2, ..., L_n], where each L_i is a list of
group weights on the i-th validation set.
.. note:: Weights are per-group for ranking tasks
In ranking task, one weight is assigned to each group (not each data
point). This is because we only care about the relative ordering of
data points within each group, so it doesn't make sense to assign
weights to individual data points.
eval_group : list of arrays, optional
A list that contains the group size corresponds to each
(X, y) pair in eval_set
eval_metric : str, callable, optional
If a str, should be a built-in evaluation metric to use. See
doc/parameter.rst. If callable, a custom evaluation metric. The call
signature is func(y_predicted, y_true) where y_true will be a
DMatrix object such that you may need to call the get_label
method. It must return a str, value pair where the str is a name
for the evaluation and value is the value of the evaluation
function. This objective is always minimized.
early_stopping_rounds : int
Activates early stopping. Validation error needs to decrease at
least every <early_stopping_rounds> round(s) to continue training.
Requires at least one item in evals. If there's more than one,
will use the last. Returns the model from the last iteration
(not the best one). If early stopping occurs, the model will
have three additional fields: bst.best_score, bst.best_iteration
and bst.best_ntree_limit.
(Use bst.best_ntree_limit to get the correct value if num_parallel_tree
and/or num_class appears in the parameters)
verbose : bool
If `verbose` and an evaluation set is used, writes the evaluation
metric measured on the validation set to stderr.
xgb_model : str
file name of stored xgb model or 'Booster' instance Xgb model to be
loaded before training (allows training continuation).
callbacks : list of callback functions
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using :ref:`callback_api`.
Example:
.. code-block:: python
[xgb.callback.reset_learning_rate(custom_rates)]
|
[
"Fit",
"the",
"gradient",
"boosting",
"model"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/sklearn.py#L1078-L1220
|
train
|
dmlc/xgboost
|
python-package/xgboost/core.py
|
from_pystr_to_cstr
|
def from_pystr_to_cstr(data):
"""Convert a list of Python str to C pointer
Parameters
----------
data : list
list of str
"""
if not isinstance(data, list):
raise NotImplementedError
pointers = (ctypes.c_char_p * len(data))()
if PY3:
data = [bytes(d, 'utf-8') for d in data]
else:
data = [d.encode('utf-8') if isinstance(d, unicode) else d # pylint: disable=undefined-variable
for d in data]
pointers[:] = data
return pointers
|
python
|
def from_pystr_to_cstr(data):
"""Convert a list of Python str to C pointer
Parameters
----------
data : list
list of str
"""
if not isinstance(data, list):
raise NotImplementedError
pointers = (ctypes.c_char_p * len(data))()
if PY3:
data = [bytes(d, 'utf-8') for d in data]
else:
data = [d.encode('utf-8') if isinstance(d, unicode) else d # pylint: disable=undefined-variable
for d in data]
pointers[:] = data
return pointers
|
[
"def",
"from_pystr_to_cstr",
"(",
"data",
")",
":",
"if",
"not",
"isinstance",
"(",
"data",
",",
"list",
")",
":",
"raise",
"NotImplementedError",
"pointers",
"=",
"(",
"ctypes",
".",
"c_char_p",
"*",
"len",
"(",
"data",
")",
")",
"(",
")",
"if",
"PY3",
":",
"data",
"=",
"[",
"bytes",
"(",
"d",
",",
"'utf-8'",
")",
"for",
"d",
"in",
"data",
"]",
"else",
":",
"data",
"=",
"[",
"d",
".",
"encode",
"(",
"'utf-8'",
")",
"if",
"isinstance",
"(",
"d",
",",
"unicode",
")",
"else",
"d",
"# pylint: disable=undefined-variable",
"for",
"d",
"in",
"data",
"]",
"pointers",
"[",
":",
"]",
"=",
"data",
"return",
"pointers"
] |
Convert a list of Python str to C pointer
Parameters
----------
data : list
list of str
|
[
"Convert",
"a",
"list",
"of",
"Python",
"str",
"to",
"C",
"pointer"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/core.py#L60-L78
|
train
|
dmlc/xgboost
|
python-package/xgboost/core.py
|
from_cstr_to_pystr
|
def from_cstr_to_pystr(data, length):
"""Revert C pointer to Python str
Parameters
----------
data : ctypes pointer
pointer to data
length : ctypes pointer
pointer to length of data
"""
if PY3:
res = []
for i in range(length.value):
try:
res.append(str(data[i].decode('ascii')))
except UnicodeDecodeError:
res.append(str(data[i].decode('utf-8')))
else:
res = []
for i in range(length.value):
try:
res.append(str(data[i].decode('ascii')))
except UnicodeDecodeError:
# pylint: disable=undefined-variable
res.append(unicode(data[i].decode('utf-8')))
return res
|
python
|
def from_cstr_to_pystr(data, length):
"""Revert C pointer to Python str
Parameters
----------
data : ctypes pointer
pointer to data
length : ctypes pointer
pointer to length of data
"""
if PY3:
res = []
for i in range(length.value):
try:
res.append(str(data[i].decode('ascii')))
except UnicodeDecodeError:
res.append(str(data[i].decode('utf-8')))
else:
res = []
for i in range(length.value):
try:
res.append(str(data[i].decode('ascii')))
except UnicodeDecodeError:
# pylint: disable=undefined-variable
res.append(unicode(data[i].decode('utf-8')))
return res
|
[
"def",
"from_cstr_to_pystr",
"(",
"data",
",",
"length",
")",
":",
"if",
"PY3",
":",
"res",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"length",
".",
"value",
")",
":",
"try",
":",
"res",
".",
"append",
"(",
"str",
"(",
"data",
"[",
"i",
"]",
".",
"decode",
"(",
"'ascii'",
")",
")",
")",
"except",
"UnicodeDecodeError",
":",
"res",
".",
"append",
"(",
"str",
"(",
"data",
"[",
"i",
"]",
".",
"decode",
"(",
"'utf-8'",
")",
")",
")",
"else",
":",
"res",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"length",
".",
"value",
")",
":",
"try",
":",
"res",
".",
"append",
"(",
"str",
"(",
"data",
"[",
"i",
"]",
".",
"decode",
"(",
"'ascii'",
")",
")",
")",
"except",
"UnicodeDecodeError",
":",
"# pylint: disable=undefined-variable",
"res",
".",
"append",
"(",
"unicode",
"(",
"data",
"[",
"i",
"]",
".",
"decode",
"(",
"'utf-8'",
")",
")",
")",
"return",
"res"
] |
Revert C pointer to Python str
Parameters
----------
data : ctypes pointer
pointer to data
length : ctypes pointer
pointer to length of data
|
[
"Revert",
"C",
"pointer",
"to",
"Python",
"str"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/core.py#L81-L106
|
train
|
dmlc/xgboost
|
python-package/xgboost/core.py
|
_load_lib
|
def _load_lib():
"""Load xgboost Library."""
lib_paths = find_lib_path()
if not lib_paths:
return None
try:
pathBackup = os.environ['PATH'].split(os.pathsep)
except KeyError:
pathBackup = []
lib_success = False
os_error_list = []
for lib_path in lib_paths:
try:
# needed when the lib is linked with non-system-available dependencies
os.environ['PATH'] = os.pathsep.join(pathBackup + [os.path.dirname(lib_path)])
lib = ctypes.cdll.LoadLibrary(lib_path)
lib_success = True
except OSError as e:
os_error_list.append(str(e))
continue
finally:
os.environ['PATH'] = os.pathsep.join(pathBackup)
if not lib_success:
libname = os.path.basename(lib_paths[0])
raise XGBoostError(
'XGBoost Library ({}) could not be loaded.\n'.format(libname) +
'Likely causes:\n' +
' * OpenMP runtime is not installed ' +
'(vcomp140.dll or libgomp-1.dll for Windows, ' +
'libgomp.so for UNIX-like OSes)\n' +
' * You are running 32-bit Python on a 64-bit OS\n' +
'Error message(s): {}\n'.format(os_error_list))
lib.XGBGetLastError.restype = ctypes.c_char_p
lib.callback = _get_log_callback_func()
if lib.XGBRegisterLogCallback(lib.callback) != 0:
raise XGBoostError(lib.XGBGetLastError())
return lib
|
python
|
def _load_lib():
"""Load xgboost Library."""
lib_paths = find_lib_path()
if not lib_paths:
return None
try:
pathBackup = os.environ['PATH'].split(os.pathsep)
except KeyError:
pathBackup = []
lib_success = False
os_error_list = []
for lib_path in lib_paths:
try:
# needed when the lib is linked with non-system-available dependencies
os.environ['PATH'] = os.pathsep.join(pathBackup + [os.path.dirname(lib_path)])
lib = ctypes.cdll.LoadLibrary(lib_path)
lib_success = True
except OSError as e:
os_error_list.append(str(e))
continue
finally:
os.environ['PATH'] = os.pathsep.join(pathBackup)
if not lib_success:
libname = os.path.basename(lib_paths[0])
raise XGBoostError(
'XGBoost Library ({}) could not be loaded.\n'.format(libname) +
'Likely causes:\n' +
' * OpenMP runtime is not installed ' +
'(vcomp140.dll or libgomp-1.dll for Windows, ' +
'libgomp.so for UNIX-like OSes)\n' +
' * You are running 32-bit Python on a 64-bit OS\n' +
'Error message(s): {}\n'.format(os_error_list))
lib.XGBGetLastError.restype = ctypes.c_char_p
lib.callback = _get_log_callback_func()
if lib.XGBRegisterLogCallback(lib.callback) != 0:
raise XGBoostError(lib.XGBGetLastError())
return lib
|
[
"def",
"_load_lib",
"(",
")",
":",
"lib_paths",
"=",
"find_lib_path",
"(",
")",
"if",
"not",
"lib_paths",
":",
"return",
"None",
"try",
":",
"pathBackup",
"=",
"os",
".",
"environ",
"[",
"'PATH'",
"]",
".",
"split",
"(",
"os",
".",
"pathsep",
")",
"except",
"KeyError",
":",
"pathBackup",
"=",
"[",
"]",
"lib_success",
"=",
"False",
"os_error_list",
"=",
"[",
"]",
"for",
"lib_path",
"in",
"lib_paths",
":",
"try",
":",
"# needed when the lib is linked with non-system-available dependencies",
"os",
".",
"environ",
"[",
"'PATH'",
"]",
"=",
"os",
".",
"pathsep",
".",
"join",
"(",
"pathBackup",
"+",
"[",
"os",
".",
"path",
".",
"dirname",
"(",
"lib_path",
")",
"]",
")",
"lib",
"=",
"ctypes",
".",
"cdll",
".",
"LoadLibrary",
"(",
"lib_path",
")",
"lib_success",
"=",
"True",
"except",
"OSError",
"as",
"e",
":",
"os_error_list",
".",
"append",
"(",
"str",
"(",
"e",
")",
")",
"continue",
"finally",
":",
"os",
".",
"environ",
"[",
"'PATH'",
"]",
"=",
"os",
".",
"pathsep",
".",
"join",
"(",
"pathBackup",
")",
"if",
"not",
"lib_success",
":",
"libname",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"lib_paths",
"[",
"0",
"]",
")",
"raise",
"XGBoostError",
"(",
"'XGBoost Library ({}) could not be loaded.\\n'",
".",
"format",
"(",
"libname",
")",
"+",
"'Likely causes:\\n'",
"+",
"' * OpenMP runtime is not installed '",
"+",
"'(vcomp140.dll or libgomp-1.dll for Windows, '",
"+",
"'libgomp.so for UNIX-like OSes)\\n'",
"+",
"' * You are running 32-bit Python on a 64-bit OS\\n'",
"+",
"'Error message(s): {}\\n'",
".",
"format",
"(",
"os_error_list",
")",
")",
"lib",
".",
"XGBGetLastError",
".",
"restype",
"=",
"ctypes",
".",
"c_char_p",
"lib",
".",
"callback",
"=",
"_get_log_callback_func",
"(",
")",
"if",
"lib",
".",
"XGBRegisterLogCallback",
"(",
"lib",
".",
"callback",
")",
"!=",
"0",
":",
"raise",
"XGBoostError",
"(",
"lib",
".",
"XGBGetLastError",
"(",
")",
")",
"return",
"lib"
] |
Load xgboost Library.
|
[
"Load",
"xgboost",
"Library",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/core.py#L121-L157
|
train
|
dmlc/xgboost
|
python-package/xgboost/core.py
|
ctypes2numpy
|
def ctypes2numpy(cptr, length, dtype):
"""Convert a ctypes pointer array to a numpy array.
"""
NUMPY_TO_CTYPES_MAPPING = {
np.float32: ctypes.c_float,
np.uint32: ctypes.c_uint,
}
if dtype not in NUMPY_TO_CTYPES_MAPPING:
raise RuntimeError('Supported types: {}'.format(NUMPY_TO_CTYPES_MAPPING.keys()))
ctype = NUMPY_TO_CTYPES_MAPPING[dtype]
if not isinstance(cptr, ctypes.POINTER(ctype)):
raise RuntimeError('expected {} pointer'.format(ctype))
res = np.zeros(length, dtype=dtype)
if not ctypes.memmove(res.ctypes.data, cptr, length * res.strides[0]):
raise RuntimeError('memmove failed')
return res
|
python
|
def ctypes2numpy(cptr, length, dtype):
"""Convert a ctypes pointer array to a numpy array.
"""
NUMPY_TO_CTYPES_MAPPING = {
np.float32: ctypes.c_float,
np.uint32: ctypes.c_uint,
}
if dtype not in NUMPY_TO_CTYPES_MAPPING:
raise RuntimeError('Supported types: {}'.format(NUMPY_TO_CTYPES_MAPPING.keys()))
ctype = NUMPY_TO_CTYPES_MAPPING[dtype]
if not isinstance(cptr, ctypes.POINTER(ctype)):
raise RuntimeError('expected {} pointer'.format(ctype))
res = np.zeros(length, dtype=dtype)
if not ctypes.memmove(res.ctypes.data, cptr, length * res.strides[0]):
raise RuntimeError('memmove failed')
return res
|
[
"def",
"ctypes2numpy",
"(",
"cptr",
",",
"length",
",",
"dtype",
")",
":",
"NUMPY_TO_CTYPES_MAPPING",
"=",
"{",
"np",
".",
"float32",
":",
"ctypes",
".",
"c_float",
",",
"np",
".",
"uint32",
":",
"ctypes",
".",
"c_uint",
",",
"}",
"if",
"dtype",
"not",
"in",
"NUMPY_TO_CTYPES_MAPPING",
":",
"raise",
"RuntimeError",
"(",
"'Supported types: {}'",
".",
"format",
"(",
"NUMPY_TO_CTYPES_MAPPING",
".",
"keys",
"(",
")",
")",
")",
"ctype",
"=",
"NUMPY_TO_CTYPES_MAPPING",
"[",
"dtype",
"]",
"if",
"not",
"isinstance",
"(",
"cptr",
",",
"ctypes",
".",
"POINTER",
"(",
"ctype",
")",
")",
":",
"raise",
"RuntimeError",
"(",
"'expected {} pointer'",
".",
"format",
"(",
"ctype",
")",
")",
"res",
"=",
"np",
".",
"zeros",
"(",
"length",
",",
"dtype",
"=",
"dtype",
")",
"if",
"not",
"ctypes",
".",
"memmove",
"(",
"res",
".",
"ctypes",
".",
"data",
",",
"cptr",
",",
"length",
"*",
"res",
".",
"strides",
"[",
"0",
"]",
")",
":",
"raise",
"RuntimeError",
"(",
"'memmove failed'",
")",
"return",
"res"
] |
Convert a ctypes pointer array to a numpy array.
|
[
"Convert",
"a",
"ctypes",
"pointer",
"array",
"to",
"a",
"numpy",
"array",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/core.py#L179-L194
|
train
|
dmlc/xgboost
|
python-package/xgboost/core.py
|
ctypes2buffer
|
def ctypes2buffer(cptr, length):
"""Convert ctypes pointer to buffer type."""
if not isinstance(cptr, ctypes.POINTER(ctypes.c_char)):
raise RuntimeError('expected char pointer')
res = bytearray(length)
rptr = (ctypes.c_char * length).from_buffer(res)
if not ctypes.memmove(rptr, cptr, length):
raise RuntimeError('memmove failed')
return res
|
python
|
def ctypes2buffer(cptr, length):
"""Convert ctypes pointer to buffer type."""
if not isinstance(cptr, ctypes.POINTER(ctypes.c_char)):
raise RuntimeError('expected char pointer')
res = bytearray(length)
rptr = (ctypes.c_char * length).from_buffer(res)
if not ctypes.memmove(rptr, cptr, length):
raise RuntimeError('memmove failed')
return res
|
[
"def",
"ctypes2buffer",
"(",
"cptr",
",",
"length",
")",
":",
"if",
"not",
"isinstance",
"(",
"cptr",
",",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char",
")",
")",
":",
"raise",
"RuntimeError",
"(",
"'expected char pointer'",
")",
"res",
"=",
"bytearray",
"(",
"length",
")",
"rptr",
"=",
"(",
"ctypes",
".",
"c_char",
"*",
"length",
")",
".",
"from_buffer",
"(",
"res",
")",
"if",
"not",
"ctypes",
".",
"memmove",
"(",
"rptr",
",",
"cptr",
",",
"length",
")",
":",
"raise",
"RuntimeError",
"(",
"'memmove failed'",
")",
"return",
"res"
] |
Convert ctypes pointer to buffer type.
|
[
"Convert",
"ctypes",
"pointer",
"to",
"buffer",
"type",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/core.py#L197-L205
|
train
|
dmlc/xgboost
|
python-package/xgboost/core.py
|
c_array
|
def c_array(ctype, values):
"""Convert a python string to c array."""
if isinstance(values, np.ndarray) and values.dtype.itemsize == ctypes.sizeof(ctype):
return (ctype * len(values)).from_buffer_copy(values)
return (ctype * len(values))(*values)
|
python
|
def c_array(ctype, values):
"""Convert a python string to c array."""
if isinstance(values, np.ndarray) and values.dtype.itemsize == ctypes.sizeof(ctype):
return (ctype * len(values)).from_buffer_copy(values)
return (ctype * len(values))(*values)
|
[
"def",
"c_array",
"(",
"ctype",
",",
"values",
")",
":",
"if",
"isinstance",
"(",
"values",
",",
"np",
".",
"ndarray",
")",
"and",
"values",
".",
"dtype",
".",
"itemsize",
"==",
"ctypes",
".",
"sizeof",
"(",
"ctype",
")",
":",
"return",
"(",
"ctype",
"*",
"len",
"(",
"values",
")",
")",
".",
"from_buffer_copy",
"(",
"values",
")",
"return",
"(",
"ctype",
"*",
"len",
"(",
"values",
")",
")",
"(",
"*",
"values",
")"
] |
Convert a python string to c array.
|
[
"Convert",
"a",
"python",
"string",
"to",
"c",
"array",
"."
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/core.py#L213-L217
|
train
|
dmlc/xgboost
|
python-package/xgboost/core.py
|
_maybe_pandas_data
|
def _maybe_pandas_data(data, feature_names, feature_types):
""" Extract internal data from pd.DataFrame for DMatrix data """
if not isinstance(data, DataFrame):
return data, feature_names, feature_types
data_dtypes = data.dtypes
if not all(dtype.name in PANDAS_DTYPE_MAPPER for dtype in data_dtypes):
bad_fields = [data.columns[i] for i, dtype in
enumerate(data_dtypes) if dtype.name not in PANDAS_DTYPE_MAPPER]
msg = """DataFrame.dtypes for data must be int, float or bool.
Did not expect the data types in fields """
raise ValueError(msg + ', '.join(bad_fields))
if feature_names is None:
if isinstance(data.columns, MultiIndex):
feature_names = [
' '.join([str(x) for x in i])
for i in data.columns
]
else:
feature_names = data.columns.format()
if feature_types is None:
feature_types = [PANDAS_DTYPE_MAPPER[dtype.name] for dtype in data_dtypes]
data = data.values.astype('float')
return data, feature_names, feature_types
|
python
|
def _maybe_pandas_data(data, feature_names, feature_types):
""" Extract internal data from pd.DataFrame for DMatrix data """
if not isinstance(data, DataFrame):
return data, feature_names, feature_types
data_dtypes = data.dtypes
if not all(dtype.name in PANDAS_DTYPE_MAPPER for dtype in data_dtypes):
bad_fields = [data.columns[i] for i, dtype in
enumerate(data_dtypes) if dtype.name not in PANDAS_DTYPE_MAPPER]
msg = """DataFrame.dtypes for data must be int, float or bool.
Did not expect the data types in fields """
raise ValueError(msg + ', '.join(bad_fields))
if feature_names is None:
if isinstance(data.columns, MultiIndex):
feature_names = [
' '.join([str(x) for x in i])
for i in data.columns
]
else:
feature_names = data.columns.format()
if feature_types is None:
feature_types = [PANDAS_DTYPE_MAPPER[dtype.name] for dtype in data_dtypes]
data = data.values.astype('float')
return data, feature_names, feature_types
|
[
"def",
"_maybe_pandas_data",
"(",
"data",
",",
"feature_names",
",",
"feature_types",
")",
":",
"if",
"not",
"isinstance",
"(",
"data",
",",
"DataFrame",
")",
":",
"return",
"data",
",",
"feature_names",
",",
"feature_types",
"data_dtypes",
"=",
"data",
".",
"dtypes",
"if",
"not",
"all",
"(",
"dtype",
".",
"name",
"in",
"PANDAS_DTYPE_MAPPER",
"for",
"dtype",
"in",
"data_dtypes",
")",
":",
"bad_fields",
"=",
"[",
"data",
".",
"columns",
"[",
"i",
"]",
"for",
"i",
",",
"dtype",
"in",
"enumerate",
"(",
"data_dtypes",
")",
"if",
"dtype",
".",
"name",
"not",
"in",
"PANDAS_DTYPE_MAPPER",
"]",
"msg",
"=",
"\"\"\"DataFrame.dtypes for data must be int, float or bool.\n Did not expect the data types in fields \"\"\"",
"raise",
"ValueError",
"(",
"msg",
"+",
"', '",
".",
"join",
"(",
"bad_fields",
")",
")",
"if",
"feature_names",
"is",
"None",
":",
"if",
"isinstance",
"(",
"data",
".",
"columns",
",",
"MultiIndex",
")",
":",
"feature_names",
"=",
"[",
"' '",
".",
"join",
"(",
"[",
"str",
"(",
"x",
")",
"for",
"x",
"in",
"i",
"]",
")",
"for",
"i",
"in",
"data",
".",
"columns",
"]",
"else",
":",
"feature_names",
"=",
"data",
".",
"columns",
".",
"format",
"(",
")",
"if",
"feature_types",
"is",
"None",
":",
"feature_types",
"=",
"[",
"PANDAS_DTYPE_MAPPER",
"[",
"dtype",
".",
"name",
"]",
"for",
"dtype",
"in",
"data_dtypes",
"]",
"data",
"=",
"data",
".",
"values",
".",
"astype",
"(",
"'float'",
")",
"return",
"data",
",",
"feature_names",
",",
"feature_types"
] |
Extract internal data from pd.DataFrame for DMatrix data
|
[
"Extract",
"internal",
"data",
"from",
"pd",
".",
"DataFrame",
"for",
"DMatrix",
"data"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/core.py#L226-L255
|
train
|
dmlc/xgboost
|
python-package/xgboost/core.py
|
_maybe_dt_data
|
def _maybe_dt_data(data, feature_names, feature_types):
"""
Validate feature names and types if data table
"""
if not isinstance(data, DataTable):
return data, feature_names, feature_types
data_types_names = tuple(lt.name for lt in data.ltypes)
bad_fields = [data.names[i]
for i, type_name in enumerate(data_types_names)
if type_name not in DT_TYPE_MAPPER]
if bad_fields:
msg = """DataFrame.types for data must be int, float or bool.
Did not expect the data types in fields """
raise ValueError(msg + ', '.join(bad_fields))
if feature_names is None:
feature_names = data.names
# always return stypes for dt ingestion
if feature_types is not None:
raise ValueError('DataTable has own feature types, cannot pass them in')
feature_types = np.vectorize(DT_TYPE_MAPPER2.get)(data_types_names)
return data, feature_names, feature_types
|
python
|
def _maybe_dt_data(data, feature_names, feature_types):
"""
Validate feature names and types if data table
"""
if not isinstance(data, DataTable):
return data, feature_names, feature_types
data_types_names = tuple(lt.name for lt in data.ltypes)
bad_fields = [data.names[i]
for i, type_name in enumerate(data_types_names)
if type_name not in DT_TYPE_MAPPER]
if bad_fields:
msg = """DataFrame.types for data must be int, float or bool.
Did not expect the data types in fields """
raise ValueError(msg + ', '.join(bad_fields))
if feature_names is None:
feature_names = data.names
# always return stypes for dt ingestion
if feature_types is not None:
raise ValueError('DataTable has own feature types, cannot pass them in')
feature_types = np.vectorize(DT_TYPE_MAPPER2.get)(data_types_names)
return data, feature_names, feature_types
|
[
"def",
"_maybe_dt_data",
"(",
"data",
",",
"feature_names",
",",
"feature_types",
")",
":",
"if",
"not",
"isinstance",
"(",
"data",
",",
"DataTable",
")",
":",
"return",
"data",
",",
"feature_names",
",",
"feature_types",
"data_types_names",
"=",
"tuple",
"(",
"lt",
".",
"name",
"for",
"lt",
"in",
"data",
".",
"ltypes",
")",
"bad_fields",
"=",
"[",
"data",
".",
"names",
"[",
"i",
"]",
"for",
"i",
",",
"type_name",
"in",
"enumerate",
"(",
"data_types_names",
")",
"if",
"type_name",
"not",
"in",
"DT_TYPE_MAPPER",
"]",
"if",
"bad_fields",
":",
"msg",
"=",
"\"\"\"DataFrame.types for data must be int, float or bool.\n Did not expect the data types in fields \"\"\"",
"raise",
"ValueError",
"(",
"msg",
"+",
"', '",
".",
"join",
"(",
"bad_fields",
")",
")",
"if",
"feature_names",
"is",
"None",
":",
"feature_names",
"=",
"data",
".",
"names",
"# always return stypes for dt ingestion",
"if",
"feature_types",
"is",
"not",
"None",
":",
"raise",
"ValueError",
"(",
"'DataTable has own feature types, cannot pass them in'",
")",
"feature_types",
"=",
"np",
".",
"vectorize",
"(",
"DT_TYPE_MAPPER2",
".",
"get",
")",
"(",
"data_types_names",
")",
"return",
"data",
",",
"feature_names",
",",
"feature_types"
] |
Validate feature names and types if data table
|
[
"Validate",
"feature",
"names",
"and",
"types",
"if",
"data",
"table"
] |
253fdd8a42d5ec6b819788199584d27bf9ea6253
|
https://github.com/dmlc/xgboost/blob/253fdd8a42d5ec6b819788199584d27bf9ea6253/python-package/xgboost/core.py#L279-L303
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.