code
stringlengths 1
13.8M
|
|---|
CxCy <- function(dat, xname, yname, ...) {
xyplot <- ggplot(dat, aes_string(x=xname, y=yname)) +
geom_point(alpha = 0.6, color = "
theme_minimal()
xyplot <- gridExtra::arrangeGrob(xyplot,
top = paste0("Scatterplot of ",
xname, " and ", yname)
)
return(xyplot)
}
QxCy <- function(dat, xname, yname, binwidth.x = NULL, binwidth.y = NULL, ...) {
box1 <- ggplot(dat, aes_string(y = yname,fill = xname)) +
geom_boxplot() +
coord_flip() +
labs(title="Boxplot") + theme_linedraw() +
theme(plot.title = element_text(size=12,
face="bold.italic", hjust = 0.5),
legend.position="bottom",
axis.text.y = element_blank(),
axis.ticks.y = element_blank()) +
theme_minimal() +
facet_grid(rows=xname)
hist1 <- ggplot(dat, aes_string(x = yname, fill = xname))+
geom_histogram(color="black", binwidth = binwidth.y)
hist1 <- hist1 +
labs(title="Histogram") + theme_linedraw() +
theme_minimal() +
theme(plot.title = element_text(size=12,
face="bold.italic", hjust = 0.5),
legend.position="bottom") +
facet_grid(rows = xname)
lay <- cbind(1,1,1,2,2)
xyplot <- gridExtra::arrangeGrob(hist1, box1, layout_matrix = lay,
top = paste0(yname,
": For different levels of ",
xname))
return(xyplot)
}
CxQy <- function(dat, xname, yname, binwidth.x = NULL, binwidth.y = NULL, ...) {
box1 <- ggplot(dat, aes_string(y = xname,fill = yname)) +
geom_boxplot() +
coord_flip() +
labs(title="Boxplot") + theme_linedraw() +
theme_minimal() +
theme(plot.title = element_text(size=12, face="bold.italic",
hjust = 0.5),
legend.position="bottom",
axis.text.y = element_blank(),
axis.ticks.y = element_blank()) +
facet_grid(rows=yname)
hist1 <- ggplot(dat, aes_string(x = xname, fill = yname))+
geom_histogram(color="black", binwidth = binwidth.x)
hist1 <- hist1 +
labs(title="Histogram") + theme_linedraw() +
theme_minimal() +
theme(plot.title = element_text(size=12, face="bold.italic",
hjust = 0.5),
legend.position="bottom") +
facet_grid(rows = yname)
lay <- cbind(1,1,1,2,2)
xyplot <- gridExtra::arrangeGrob(hist1, box1, layout_matrix = lay,
top = paste0(xname,
": For different levels of ",
yname))
return(xyplot)
}
QxQy <- function(dat, xname, yname, ...) {
x <- dat[, xname]
y <- dat[, yname]
crosstab <- setNames(data.frame(table(x, y)),
c(xname, yname,"Count"))
xyplot <- ggplot(crosstab, aes_string(xname, yname, fill= "Count")) +
geom_tile(color = "grey69") +
scale_fill_gradient2(low="white", high="
geom_text(aes(label=Count))+
theme_minimal() +
theme(panel.grid.major=element_blank(),
plot.title = element_text(hjust = 0.5, size = 12),
legend.position = "blank") +
coord_flip()
xyplot <- gridExtra::arrangeGrob(xyplot,
top = paste0("Crosstab of ",
xname, " and ", yname)
)
return(xyplot)
}
Cx <- function(dat, xname, binwidth = NULL, inc.density = T, ...) {
quants <- quantile(dat[,1], na.rm = T)
iqr_ <- quants[4]-quants[2]
quantdf <- data.frame(Value = c(quants[2]-iqr_*1.5,
quants[3],
quants[4]+1.5*iqr_),
labels=c("Whiskers","Median","Whiskers"))
p1 <- ggplot(dat, aes_string(x=xname)) +
geom_rect(aes(xmin = quants[2], xmax = quants[4],
ymin = 0, ymax = Inf, fill = "IQR"),
color=NA, alpha = 0.002)
if (inc.density) {
p1 <- p1 + geom_density(aes(y = ..density..),
alpha=.2, fill="
stat_bin(aes(y=..density..), colour="black",
fill="
titl <- "Histogram & Density plot"
ytitl <- "Density"
} else {
p1 <- p1 + geom_histogram(color="black", binwidth = binwidth)
titl <- "Histogram"
ytitl <- "Frequency"
}
p1 <- p1 +
labs(title=titl, y=ytitl) +
scale_fill_manual('',
values = '
guide = guide_legend(override.aes = list(alpha = 0.5))) +
theme_minimal() +
theme(plot.title = element_text(size=12, face="bold.italic", hjust = 0.5),
legend.position = "bottom") +
geom_vline(aes(xintercept=Value, color=labels),
data=quantdf, show.legend=T) +
scale_color_manual("", values=c("Whiskers"="grey4",
"Median"="
"Whiskers"="grey4"))
return(p1)
}
Qx <- function(dat, xname, ...) {
piedf <- dplyr::group_by(dat, !!as.name(xname))
piedf <- dplyr::summarise(piedf, counts = n())
piedf <- dplyr::arrange(piedf, desc(counts))
piedf <- dplyr::mutate(piedf, prop = round(counts*100/sum(counts), 1),
lab.ypos = cumsum(prop) - 0.5*prop)
p1 <- ggplot(piedf, aes(x = "", y = prop, fill = !!as.name(xname))) +
geom_bar(width = 1, stat = "identity", color = "white") +
coord_polar("y", start = 0)+
labs(title=paste0("Distribution of ", xname), x = NULL,y=NULL)+
theme_void() + theme(legend.position="bottom") +
theme(plot.title = element_text(size=12, face="bold.italic", hjust = 0.5))
return(p1)
} |
test_that("calcProb_value", {
item_1 <- new("item_1PL", difficulty = 0.5)
item_2 <- new("item_2PL", slope = 1.5, difficulty = 0.5)
item_3 <- new("item_3PL", slope = 1.0, difficulty = 0.5, guessing = 0.2)
item_4 <- new("item_PC", threshold = c(-1, 0, 1), ncat = 4)
item_5 <- new("item_GPC", slope = 1.2, threshold = c(-0.8, -1.0, 0.5), ncat = 4)
item_6 <- new("item_GR", slope = 0.9, category = c(-1, 0, 1), ncat = 4)
theta_vec <- seq(-3, 3, 1)
tol <- 1e-06
expect_equal(
log(prod(calcProb(item_1, theta_vec))),
-15.57702,
tolerance = tol)
expect_equal(
log(prod(calcProb(item_2, theta_vec))),
-20.80176,
tolerance = tol)
expect_equal(
log(prod(calcProb(item_3, theta_vec))),
-12.77404,
tolerance = tol)
expect_equal(
log(prod(calcProb(item_4, theta_vec))),
-76.95776,
tolerance = tol)
expect_equal(
log(prod(calcProb(item_5, theta_vec))),
-91.78112,
tolerance = tol)
expect_equal(
log(prod(calcProb(item_6, theta_vec))),
-52.22233,
tolerance = tol)
expect_equal(
mean(log(unlist(calcProb(itempool_science, theta_vec)))),
-1.250381,
tolerance = tol)
expect_equal(
mean(log(unlist(calcProb(itempool_reading, theta_vec)))),
-1.732649,
tolerance = tol)
expect_equal(
mean(log(unlist(calcProb(itempool_fatigue, theta_vec)))),
-5.295978,
tolerance = tol)
expect_equal(
mean(log(unlist(calcProb(itempool_bayes, theta_vec)))),
-1.097485,
tolerance = tol)
}) |
GenerateRandomClustering <- function(nElement , nClust , Prob = NULL)
{
if(is.null(Prob))
{
Prob <- rep(x = (1/nClust) , nClust)
}
BestClust = NULL
ErrorEncountered = F
if (!(length(Prob) == nClust))
{
ErrorEncountered = T
}
if ((abs(sum(Prob) - 1) > .000000001) | (any(Prob < 0)))
{
ErrorEncountered = T
}
if (!(any(nClust == 1:nElement)))
{
ErrorEncountered = T
}
if (!(ErrorEncountered))
{
if (nElement > nClust)
{
if (nClust == 1)
{
BestClust = rep(1 , times = nElement)
}
else
{
ProbVV = round(Prob * nElement)
if (!(sum(ProbVV) == nElement) |
(any(ProbVV < 1)))
{
ProbVV = AdjustProb(ProbVV , nElement)
}
tempclus = rep(1:length(ProbVV) , ProbVV)
BestClust = tempclus[sample(1:nElement,size = nElement,replace =
FALSE)]
}
}
else
{
BestClust = 1:nClust
}
}
if (!(length(unique(BestClust)) == nClust))
{
BestClust = NULL
}
return(BestClust)
} |
print.rm5 <- function(x, comp.no, outcome.no, ...) {
chkclass(x, "rm5")
if (missing(comp.no))
comp.no <- unique(x$comp.no)
res <- list()
n <- 1
for (i in comp.no) {
if (missing(outcome.no))
jj <- unique(x$outcome.no[x$comp.no == i])
else
jj <- outcome.no
for (j in jj) {
res[[n]] <- metacr(x, i, j, ...)
n <- n + 1
}
}
n <- 1
for (i in seq_len(length(res))) {
if (n > 1)
cat("\n*****\n\n")
print(res[[n]])
n <- n + 1
}
invisible(NULL)
} |
process_config <- list(
privileged = FALSE,
user = "1000",
tty = TRUE,
entrypoint = "sh",
arguments = c("-c", "exit 2"))
list(
id = "f33bbfb39f5b142420f4759b2348913bd4a8d1a6d7fd56499cb41a1bb91d7b3b",
running = FALSE,
exit_code = 2L,
process_config = process_config,
open_stdin = TRUE,
open_stderr = TRUE,
open_stdout = TRUE,
container_id =
"b53ee82b53a40c7dca428523e34f741f3abc51d9f297a14ff874bf761b995126",
pid = 42000L) |
context("Student data distribution")
library(adoptr)
library(testthat)
test_that("Constructor works", {
expect_true(
Student()@two_armed)
expect_true(
!Student(two_armed = FALSE)@two_armed)
expect_equal(
Student(TRUE)@multiplier, 2)
expect_equal(
Student(FALSE)@multiplier, 1)
})
test_that("pdf is defined correctly", {
dist <- Student(TRUE)
x <- seq(-3, 3, by = .1)
n <- 22
theta <- .35
expect_equal(
probability_density_function(dist, x, n, theta),
stats::dt(x, df = 2 * (n - 1), ncp = sqrt(n / 2) * theta),
tolerance = 1e-6, scale = 1)
})
test_that("cdf is defined correctly", {
dist <- Student(FALSE)
x <- seq(-3, 3, by = .1)
n <- 11
theta <- 0.24
expect_equal(
cumulative_distribution_function(dist, x, n, theta),
stats::pt(x, df = 1 * (n - 1), ncp = sqrt(n / 1) * theta),
tolerance = 1e-6, scale = 1)
})
test_that("quantile is defined correctly", {
dist <- Student(TRUE)
probs <- seq(.01, 1, by = .01)
n <- 7
theta <- -.1
expect_equal(
quantile(dist, probs, n, theta),
stats::qt(probs, df = 2 * (n - 1), ncp = sqrt(n / 2) * theta),
tolerance = 1e-6, scale = 1)
expect_warning(
quantile(dist, -1, n, theta)
)
})
test_that("vectorization works", {
dist <- Student(two_armed = TRUE)
prior <- PointMassPrior(c(.3, .4), c(.4, .6))
expect_equal(
predictive_pdf(dist, prior, c(0, 1), 10),
sapply(c(0, 1), function(x) predictive_pdf(dist, prior, x, 10))
)
})
test_that("simulate respects seed", {
expect_equal(
simulate(Student(), 10, 10, 0, seed = 42),
simulate(Student(), 10, 10, 0, seed = 42),
tolerance = 1e-6, scale = 1)
set.seed(42)
expect_true(
all(simulate(Student(), 10, 12, -.1) != simulate(Student(), 10, 12, -.1)))
})
test_that("Student needs larger sample sizes than normal", {
dist1 <- Student()
pow1 <- Power(dist1, PointMassPrior(.3,1))
ess1 <- ExpectedSampleSize(dist1, PointMassPrior(.3, 1))
toer1 <- Power(dist1, PointMassPrior(0,1))
opt1 <- minimize(ess1, subject_to(pow1>=.9, toer1<=.025), OneStageDesign(200,2))$design
dist2 <- Normal()
pow2 <- Power(dist2, PointMassPrior(.3,1))
ess2 <- ExpectedSampleSize(dist2, PointMassPrior(.3, 1))
toer2 <- Power(dist2, PointMassPrior(0,1))
opt2 <- minimize(ess2, subject_to(pow2>=.9, toer2<=.025), OneStageDesign(200,2))$design
expect_lte(
opt2@n1,
opt1@n1
)
})
test_that("Published results are reproducible", {
dist <- Student(TRUE)
H_0 <- PointMassPrior(0, 1)
ess <- ExpectedSampleSize(dist, H_0)
toer <- Power(dist, H_0)
pow1 <- Power(dist, PointMassPrior(1.5, 1))
osd1 <- minimize(ess, subject_to(toer <= 0.025, pow1 >= 0.8),
OneStageDesign(20, 2))$design
expect_equal(ceiling(osd1@n1), 18 / 2)
pow2 <- Power(dist, PointMassPrior(1.0, 1))
osd2 <- minimize(ess, subject_to(toer <= 0.025, pow2 >= 0.8),
OneStageDesign(20, 2))$design
expect_equal(ceiling(osd2@n1), 34 / 2)
pow3 <- Power(dist, PointMassPrior(0.5, 1))
osd3 <- minimize(ess, subject_to(toer <= 0.025, pow3 >= 0.8),
OneStageDesign(20, 2))$design
expect_equal(ceiling(osd3@n1), 128 / 2)
})
test_that("show method", {
expect_equal(
capture.output(show(Student())),
"Student<two-armed> "
)
expect_equal(
capture.output(show(Student(two_armed = FALSE))),
"Student<single-armed> "
)
}) |
lets.subsetPAM <- function(x, names, remove.cells = TRUE) {
if (class(x)[1] != "PresenceAbsence") {
stop("x argument must be a PresenceAbsence object")
}
if (class(names)[1] != "character") {
stop("names argument must be a character object")
}
if (class(remove.cells)[1] != "logical") {
stop("remove.cells argument must be a TRUE or FALSE")
}
pos <- colnames(x[[1]]) %in% names
errorcont <- names %in% colnames(x[[1]])
if (!any(errorcont)) {
stop("None of the names provided match with PAM species")
}
if (any(!errorcont)) {
warning(paste("One or more names",
"provided, do not",
"match any of the",
"PAM species"))
}
x[[1]] <- x[[1]][, c(1:2, which(pos)), drop = FALSE]
if (remove.cells) {
x[[1]] <- .removeCells(x[[1]])
}
rich <- rowSums(x[[1]][, -(1:2), drop = FALSE])
x[[2]] <- rasterize(x[[1]][, c(1:2), drop = FALSE], x[[2]], rich)
x[[3]] <- colnames(x[[1]])[-c(1:2)]
return(x)
} |
context("test-g01-problem")
TOL <- 1e-6
a <- Variable(name = "a")
b <- Variable(name = "b")
c <- Variable(name = "c")
x <- Variable(2, name = "x")
y <- Variable(3, name = "y")
z <- Variable(2, name = "z")
A <- Variable(2, 2, name = "A")
B <- Variable(2, 2, name = "B")
C <- Variable(3, 2, name = "C")
ConicSolver <- CVXR:::ConicSolver
INSTALLED_SOLVERS <- installed_solvers()
SCS.dims_to_solver_dict <- CVXR:::SCS.dims_to_solver_dict
ECOS.dims_to_solver_dict <- CVXR:::ECOS.dims_to_solver_dict
.p_norm <- CVXR:::.p_norm
test_that("test the variables method", {
skip_on_cran()
p <- Problem(Minimize(a), list(a <= x, b <= A + 2))
vars_ <- variables(p)
ref <- list(a, x, b, A)
mapply(function(v, r) { expect_equal(v, r) }, vars_, ref)
})
test_that("test the parameters method", {
skip_on_cran()
p1 <- Parameter()
p2 <- Parameter(3, nonpos = TRUE)
p3 <- Parameter(4, 4, nonneg = TRUE)
p <- Problem(Minimize(p1), list(a + p1 <= p2, b <= p3 + p3 + 2))
params <- parameters(p)
ref <- c(p1, p2, p3)
mapply(function(p, r) { expect_equal(p, r) }, params, ref)
})
test_that("test the constants method", {
skip_on_cran()
c1 <- matrix(stats::rnorm(2), nrow = 1, ncol = 2)
c2 <- matrix(stats::rnorm(2), nrow = 2, ncol = 1)
p <- Problem(Minimize(c1 %*% x), list(x >= c2))
constants_ <- constants(p)
ref <- list(c1, c2)
expect_equal(length(constants_), length(ref))
mapply(function(c, r) {
expect_equal(dim(c), dim(r))
expect_true(all(value(c) == r))
}, constants_, ref)
p <- Problem(Minimize(a), list(x >= 1))
constants_ <- constants(p)
ref <- list(matrix(1))
expect_equal(length(ref), length(constants_))
mapply(function(c, r) {
expect_equal(dim(c), dim(r))
expect_true(all(value(c) == r))
}, constants_, ref)
})
test_that("Test the size_metrics method", {
skip_on_cran()
p1 <- Parameter()
p2 <- Parameter(3, nonpos = TRUE)
p3 <- Parameter(4, 4, nonneg = TRUE)
c1 <- matrix(stats::rnorm(2), nrow = 2, ncol = 1)
c2 <- matrix(stats::rnorm(2), nrow = 1, ncol = 2)
constants <- c(2, as.numeric(c2 %*% c1))
p <- Problem(Minimize(p1), list(a + p1 <= p2, b <= p3 + p3 + constants[1], c == constants[2]))
n_variables <- size_metrics(p)@num_scalar_variables
ref <- size(a) + size(b) + size(c)
expect_equal(n_variables, ref)
n_data <- size_metrics(p)@num_scalar_data
ref <- size(p1) + size(p2) + size(p3) + length(constants)
expect_equal(n_data, ref)
n_eq_constr <- size_metrics(p)@num_scalar_eq_constr
ref <- prod(dim(c2 %*% c1))
expect_equal(n_eq_constr, ref)
n_leq_constr <- size_metrics(p)@num_scalar_leq_constr
ref <- size(p3) + size(p2)
expect_equal(n_leq_constr, ref)
max_data_dim <- size_metrics(p)@max_data_dimension
ref <- max(dim(p3))
expect_equal(max_data_dim, ref)
})
test_that("Test the solver_stats method", {
skip_on_cran()
prob <- Problem(Minimize(p_norm(x)), list(x == 0))
result <- solve(prob, solver = "ECOS")
expect_true(result$solve_time > 0)
expect_true(result$setup_time > 0)
expect_true(result$num_iters > 0)
})
test_that("Test the get_problem_data method", {
skip_on_cran()
data <- get_problem_data(Problem(Minimize(exp(a) + 2)), "SCS")[[1]]
dims <- data[[ConicSolver()@dims]]
expect_equal(dims@exp, 1)
expect_equal(length(data[["c"]]), 2)
expect_equal(dim(data[["A"]]), c(3,2))
data <- get_problem_data(Problem(Minimize(p_norm(x) + 3)), "ECOS")[[1]]
dims <- data[[ConicSolver()@dims]]
expect_equal(dims@soc, list(3))
expect_equal(length(data[["c"]]), 3)
expect_equal(dim(data[["A"]]), c(0,0))
expect_equal(dim(data[["G"]]), c(3,3))
if("CVXOPT" %in% INSTALLED_SOLVERS) {
data <- get_problem_data(Problem(Minimize(p_norm(x) + 3)), "CVXOPT")[[1]]
dims <- data[["dims"]]
expect_equal(dims@soc, list(3))
}
})
test_that("Test unpack results method", {
skip_on_cran()
prob <- Problem(Minimize(exp(a)), list(a == 0))
tmp <- get_problem_data(prob, solver = "SCS")
args <- tmp[[1]]
chain <- tmp[[2]]
inv <- tmp[[3]]
data <- list(c = args[["c"]], A = args[["A"]], b = args[["b"]])
cones <- SCS.dims_to_solver_dict(args[[ConicSolver()@dims]])
solution <- scs::scs(A = data$A, b = data$b, obj = data$c, cone = cones)
prob <- Problem(Minimize(exp(a)), list(a == 0))
result <- unpack_results(prob, solution, chain, inv)
expect_equal(result$getValue(a), 0, tolerance = 1e-3)
expect_equal(result$value, 1, tolerance = 1e-3)
expect_equal(result$status, "optimal")
prob <- Problem(Minimize(p_norm(x)), list(x == 0))
tmp <- get_problem_data(prob, solver = "ECOS")
args <- tmp[[1]]
chain <- tmp[[2]]
inv <- tmp[[3]]
cones <- ECOS.dims_to_solver_dict(args[[ConicSolver()@dims]])
solution <- ECOSolveR::ECOS_csolve(args[["c"]], args[["G"]], args[["h"]], cones, args[["A"]], args[["b"]])
prob <- Problem(Minimize(p_norm(x)), list(x == 0))
result <- unpack_results(prob, solution, chain, inv)
expect_equal(result$getValue(x), matrix(c(0,0)))
expect_equal(result$value, 0)
expect_equal(result$status, "optimal")
})
test_that("test the is_dcp method", {
skip_on_cran()
p <- Problem(Minimize(norm_inf(a)))
expect_true(is_dcp(p))
p <- Problem(Maximize(norm_inf(a)))
expect_false(is_dcp(p))
expect_error(solve(p))
})
test_that("test the is_qp method", {
skip_on_cran()
A <- matrix(rnorm(4*3), nrow = 4, ncol = 3)
b <- matrix(rnorm(4), nrow = 4)
Aeq <- matrix(rnorm(2*3), nrow = 2, ncol = 3)
beq <- matrix(rnorm(2), nrow = 2, ncol = 1)
Fmat <- matrix(rnorm(2*3), nrow = 2, ncol = 3)
g <- matrix(rnorm(2), nrow = 2, ncol = 1)
obj <- sum_squares(A %*% y - b)
qpwa_obj <- 3*sum_squares(-abs(A %*% y)) + quad_over_lin(max_elemwise(abs(A %*% y), rep(3, 4)), 2)
not_qpwa_obj <- 3*sum_squares(abs(A %*% y)) + quad_over_lin(min_elemwise(abs(A %*% y), rep(3, 4)), 2)
p <- Problem(Minimize(obj), list())
expect_true(is_qp(p))
p <- Problem(Minimize(qpwa_obj), list())
expect_true(is_qp(p))
p <- Problem(Minimize(not_qpwa_obj), list())
expect_false(is_qp(p))
p <- Problem(Minimize(obj), list(Aeq %*% y == beq, Fmat %*% y <= g))
expect_true(is_qp(p))
p <- Problem(Minimize(obj), list(max_elemwise(1, 3*y) <= 200, abs(2*y) <= 100, p_norm(2*y, 1) <= 1000, Aeq %*% y == beq))
expect_true(is_qp(p))
p <- Problem(Minimize(qpwa_obj), list(max_elemwise(1, 3*y) <= 200, abs(2*y) <= 100, p_norm(2*y, 1) <= 1000, Aeq %*% y == beq))
expect_true(is_qp(p))
p <- Problem(Minimize(obj), list(max_elemwise(1, 3*y^2) <= 200))
expect_false(is_qp(p))
p <- Problem(Minimize(qpwa_obj), list(max_elemwise(1, 3*y^2) <= 200))
expect_false(is_qp(p))
})
test_that("test problems involving variables with the same name", {
skip_on_cran()
var <- Variable(name = "a")
p <- Problem(Maximize(a + var), list(var == 2 + a, var <= 3))
result <- solve(p)
expect_equal(result$value, 4.0, tolerance = TOL)
expect_equal(result$getValue(a), 1, tolerance = TOL)
expect_equal(result$getValue(var), 3, tolerance = TOL)
})
test_that("test adding problems", {
skip_on_cran()
prob1 <- Problem(Minimize(a), list(a >= b))
prob2 <- Problem(Minimize(2*b), list(a >= 1, b >= 2))
prob_minimize <- prob1 + prob2
expect_equal(length(prob_minimize@constraints), 3)
result <- solve(prob_minimize)
expect_equal(result$value, 6, tolerance = TOL)
prob3 <- Problem(Maximize(a), list(b <= 1))
prob4 <- Problem(Maximize(2*b), list(a <= 2))
prob_maximize <- prob3 + prob4
expect_equal(length(prob_maximize@constraints), 2)
result <- solve(prob_maximize)
expect_equal(result$value, 4, tolerance = TOL)
prob5 <- Problem(Minimize(3*a))
prob_sum <- Reduce("+", list(prob1, prob2, prob5))
expect_equal(length(prob_sum@constraints), 3)
result <- solve(prob_sum)
expect_equal(result$value, 12, tolerance = TOL)
prob_sum <- Reduce("+", list(prob1))
expect_equal(length(prob_sum@constraints), 1)
expect_error(prob_bad_sum <- prob1 + prob3, "Problem does not follow DCP rules")
})
test_that("test problem multiplication by scalar", {
skip_on_cran()
prob1 <- Problem(Minimize(a^2), list(a >= 2))
answer <- solve(prob1)$value
factors <- c(0, 1, 2.3, -4.321)
for(f in factors) {
expect_equal(solve(f * prob1)$value, f * answer, tolerance = TOL)
expect_equal(solve(prob1 * f)$value, f * answer, tolerance = TOL)
}
})
test_that("test problem linear combinations", {
skip_on_cran()
prob1 <- Problem(Minimize(a), list(a >= b))
prob2 <- Problem(Minimize(2*b), list(a >= 1, b >= 2))
prob3 <- Problem(Maximize(-(b + a)^2), list(b >= 3))
combo1 <- prob1 + 2 * prob2
combo1_ref <- Problem(Minimize(a + 4*b), list(a >= b, a >= 1, b >= 2))
expect_equal(solve(combo1)$value, solve(combo1_ref)$value)
combo2 <- prob1 - prob3/2
combo2_ref <- Problem(Minimize(a + (b + a)^2/2), list(b >= 3, a >= b))
expect_equal(solve(combo2)$value, solve(combo2_ref)$value)
combo3 <- prob1 + 0*prob2 - 3*prob3
combo3_ref <- Problem(Minimize(a + 3*(b + a)^2), list(a >= b, a >= 1, b >= 3))
expect_equal(solve(combo3)$value, solve(combo3_ref)$value, tolerance = TOL)
})
test_that("Test scalar LP problems", {
skip_on_cran()
p <- Problem(Minimize(3*a), list(a >= 2))
result <- solve(p)
expect_equal(result$value, 6, tolerance = TOL)
expect_equal(result$getValue(a), 2, tolerance = TOL)
p <- Problem(Maximize(3*a - b), list(a <= 2, b == a, b <= 5))
result <- solve(p)
expect_equal(result$value, 4.0, tolerance = TOL)
expect_equal(result$getValue(a), 2, tolerance = TOL)
expect_equal(result$getValue(b), 2, tolerance = TOL)
p <- Problem(Minimize(3*a - b + 100), list(a >= 2, b + 5*c - 2 == a, b <= 5 + c))
result <- solve(p)
expect_equal(result$value, 101+1.0/6, tolerance = TOL)
expect_equal(result$getValue(a), 2, tolerance = TOL)
expect_equal(result$getValue(b), 5-1.0/6, tolerance = TOL)
expect_equal(result$getValue(c), -1.0/6, tolerance = TOL)
exp <- Maximize(a)
p <- Problem(exp, list(a <= 2))
result <- solve(p, solver = "ECOS")
expect_equal(result$status, "optimal")
expect_false(is.na(result$getValue(a)))
expect_false(is.na(result$getDualValue(p@constraints[[1]])))
p <- Problem(Maximize(a), list(a >= 2))
result <- solve(p, solver = "ECOS")
expect_equal(result$value, Inf)
expect_true(is.na(result$getValue(a)))
expect_true(is.na(result$getDualValue(p@constraints[[1]])))
if("CVXOPT" %in% INSTALLED_SOLVERS) {
p <- Problem(Minimize(-a), list(a >= 2))
result <- solve(p, solver = "CVXOPT")
expect_equal(result$status, "unbounded")
expect_equal(result$value, -Inf)
}
p <- Problem(Maximize(a), list(a >= 2, a <= 1))
result <- solve(p, solver = "ECOS")
expect_equal(result$status, "infeasible")
expect_equal(result$value, -Inf)
expect_true(is.na(result$getValue(a)))
expect_true(is.na(result$getDualValue(p@constraints[[1]])))
p <- Problem(Minimize(-a), list(a >= 2, a <= 1))
result <- solve(p, solver = "ECOS")
expect_equal(result$status, "infeasible")
expect_equal(result$value, Inf)
})
test_that("Test vector LP problems", {
skip_on_cran()
c <- Constant(matrix(c(1, 2), nrow = 2, ncol = 1))@value
p <- Problem(Minimize(t(c) %*% x), list(x >= c))
result <- solve(p)
expect_equal(result$value, 5, tolerance = TOL)
expect_equal(result$getValue(x), matrix(c(1, 2)), tolerance = TOL)
A <- Constant(rbind(c(3, 5), c(1, 2)))@value
I <- Constant(rbind(c(1, 0), c(0, 1)))
p <- Problem(Minimize(t(c) %*% x + a), list(A %*% x >= c(-1, 1), 4*I %*% z == x, z >= c(2,2), a >= 2))
result <- solve(p)
expect_equal(result$value, 26, tolerance = 1e-3)
obj <- result$getValue(t(c) %*% x + a)
expect_equal(obj, result$value, tolerance = TOL)
expect_equal(result$getValue(x), matrix(c(8,8)), tolerance = 1e-3)
expect_equal(result$getValue(z), matrix(c(2,2)), tolerance = 1e-3)
})
test_that("Test ECOS with no inequality constraints", {
skip_on_cran()
Tmat <- value(Constant(matrix(1, nrow = 2, ncol = 2)))
p <- Problem(Minimize(1), list(A == Tmat))
result <- solve(p, solver = "ECOS")
expect_equal(result$value, 1, tolerance = TOL)
expect_equal(result$getValue(A), Tmat, tolerance = TOL)
})
test_that("Test matrix LP problems", {
skip_on_cran()
Tmat <- value(Constant(matrix(1, nrow = 2, ncol = 2)))
p <- Problem(Minimize(1), list(A == Tmat))
result <- solve(p)
expect_equal(result$value, 1, tolerance = TOL)
expect_equal(result$getValue(A), Tmat, tolerance = TOL)
Tmat <- value(Constant(matrix(1, nrow = 2, ncol = 3)*2))
p <- Problem(Minimize(1), list(A >= Tmat %*% C, A == B, C == t(Tmat)))
result <- solve(p)
expect_equal(result$value, 1, tolerance = TOL)
expect_equal(result$getValue(A), result$getValue(B), tolerance = TOL)
expect_equal(result$getValue(C), t(Tmat), tolerance = TOL)
expect_true(all(result$getValue(A) >= Tmat %*% result$getValue(C)))
expect_true(is(result$getValue(A), "matrix"))
})
test_that("Test variable promotion", {
skip_on_cran()
p <- Problem(Minimize(a), list(x <= a, x == c(1, 2)))
result <- solve(p)
expect_equal(result$value, 2, tolerance = TOL)
expect_equal(result$getValue(a), 2, tolerance = TOL)
p <- Problem(Minimize(a), list(A <= a, A == rbind(c(1,2), c(3,4))))
result <- solve(p)
expect_equal(result$value, 4, tolerance = TOL)
expect_equal(result$getValue(a), 4, tolerance = TOL)
p <- Problem(Minimize(matrix(1, nrow = 1, ncol = 2) %*% (x + a + 1)), list(a + x >= c(1, 2)))
result <- solve(p)
expect_equal(result$value, 5, tolerance = TOL)
})
test_that("Test parameter promotion", {
skip_on_cran()
a <- Parameter()
value(a) <- 2
exp <- cbind(c(1,2), c(3,4))*a
expect_false(any(value(exp) - 2*cbind(c(1,2), c(3,4)) != 0))
})
test_that("test problems with parameters", {
skip_on_cran()
p1 <- Parameter()
p2 <- Parameter(3, nonpos = TRUE)
p3 <- Parameter(4, 4, nonneg = TRUE)
p <- Problem(Maximize(p1*a), list(a + p1 <= p2, b <= p3 + p3 + 2))
value(p1) <- 2
value(p2) <- -matrix(1, nrow = 3, ncol = 1)
value(p3) <- matrix(1, nrow = 4, ncol = 4)
result <- solve(p)
expect_equal(result$value, -6, tolerance = TOL)
value(p1) <- NA_real_
p <- Problem(Maximize(p1*a), list(a + p1 <= p2, b <= p3 + p3 + 2))
expect_error(solve(p))
})
test_that("test problems with norm_inf", {
skip_on_cran()
p <- Problem(Minimize(norm_inf(-2)))
result <- solve(p)
expect_equal(result$value, 2, tolerance = TOL)
p <- Problem(Minimize(norm_inf(a)), list(a >= 2))
result <- solve(p)
expect_equal(result$value, 2, tolerance = TOL)
expect_equal(result$getValue(a), 2, tolerance = TOL)
p <- Problem(Minimize(3*norm_inf(a + 2*b) + c), list(a >= 2, b <= -1, c == 3))
result <- solve(p)
expect_equal(result$value, 3, tolerance = TOL)
expect_equal(result$getValue(a + 2*b), 0, tolerance = TOL)
expect_equal(result$getValue(c), 3, tolerance = TOL)
p <- Problem(Maximize(-norm_inf(a)), list(a <= -2))
result <- solve(p)
expect_equal(result$value, -2, tolerance = TOL)
expect_equal(result$getValue(a), -2, tolerance = TOL)
p <- Problem(Minimize(norm_inf(x - z) + 5), list(x >= c(2,3), z <= c(-1,-4)))
result <- solve(p, solver = "ECOS")
expect_equal(result$value, 12, tolerance = TOL)
expect_equal(result$getValue(x[2] - z[2]), 7, tolerance = TOL)
})
test_that("Test problems with norm1", {
skip_on_cran()
p <- Problem(Minimize(norm1(-2)))
result <- solve(p)
expect_equal(result$value, 2, tolerance = TOL)
p <- Problem(Minimize(norm1(a)), list(a <= -2))
result <- solve(p)
expect_equal(result$value, 2, tolerance = TOL)
expect_equal(result$getValue(a), -2, tolerance = TOL)
p <- Problem(Maximize(-norm1(a)), list(a <= -2))
result <- solve(p)
expect_equal(result$value, -2, tolerance = TOL)
expect_equal(result$getValue(a), -2, tolerance = TOL)
p <- Problem(Minimize(norm1(x - z) + 5), list(x >= c(2,3), z <= c(-1,-4)))
result <- solve(p)
expect_equal(result$value, 15, tolerance = TOL)
expect_equal(result$getValue(x[2] - z[2]), 7, tolerance = TOL)
})
test_that("Test problems with norm2", {
skip_on_cran()
p <- Problem(Minimize(norm2(-2)))
result <- solve(p)
expect_equal(result$value, 2, tolerance = TOL)
p <- Problem(Minimize(norm2(a)), list(a <= -2))
result <- solve(p)
expect_equal(result$value, 2, tolerance = TOL)
expect_equal(result$getValue(a), -2, tolerance = TOL)
p <- Problem(Maximize(-norm2(a)), list(a <= -2))
result <- solve(p)
expect_equal(result$value, -2, tolerance = TOL)
expect_equal(result$getValue(a), -2, tolerance = TOL)
p <- Problem(Minimize(norm2(x - z) + 5), list(x >= c(2,3), z <= c(-1,-4)))
result <- solve(p)
expect_equal(result$value, 12.61577, tolerance = TOL)
expect_equal(result$getValue(x), matrix(c(2,3)), tolerance = TOL)
expect_equal(result$getValue(z), matrix(c(-1,-4)), tolerance = TOL)
p <- Problem(Minimize(norm2(t(x - z)) + 5), list(x >= c(2,3), z <= c(-1,-4)))
result <- solve(p)
expect_equal(result$value, 12.61577, tolerance = TOL)
expect_equal(result$getValue(x), matrix(c(2,3)), tolerance = TOL)
expect_equal(result$getValue(z), matrix(c(-1,-4)), tolerance = TOL)
})
test_that("Test problems with abs", {
skip_on_cran()
p <- Problem(Minimize(sum_entries(abs(A))), list(-2 >= A))
result <- solve(p)
expect_equal(result$value, 8, tolerance = TOL)
expect_equal(result$getValue(A), matrix(rep(-2, 4), nrow = 2, ncol = 2), tolerance = TOL)
})
test_that("Test problems with quad_form", {
skip_on_cran()
expect_error(solve(Problem(Minimize(quad_form(x, A)))), "At least one argument to QuadForm must be constant.")
expect_error(solve(Problem(Minimize(quad_form(1, A)))), "Invalid dimensions for arguments.")
expect_error(solve(Problem(Minimize(quad_form(x, rbind(c(-1,0), c(0,9)))))))
P <- rbind(c(4,0), c(0,9))
p <- Problem(Minimize(quad_form(x, P)), list(x >= 1))
result <- solve(p)
expect_equal(result$value, 13, tolerance = 1e-3)
c <- c(1,2)
p <- Problem(Minimize(quad_form(c, A)), list(A >= 1))
result <- solve(p)
expect_equal(result$value, 9, tolerance = TOL)
c <- c(1,2)
P <- rbind(c(4,0), c(0,9))
p <- Problem(Minimize(quad_form(c, P)))
result <- solve(p)
expect_equal(result$value, 40)
})
test_that("Test combining atoms", {
skip_on_cran()
p <- Problem(Minimize(norm2(5 + p_norm(z,1) + p_norm(x,1) + norm_inf(x - z))), list(x >= c(2,3), z <= c(-1,-4), p_norm(x + z,2) <= 2))
result <- solve(p)
expect_equal(result$value, 22, tolerance = TOL)
expect_equal(result$getValue(x), matrix(c(2,3)), tolerance = TOL)
expect_equal(result$getValue(z), matrix(c(-1,-4)), tolerance = TOL)
})
test_that("Test multiplying by constant atoms", {
skip_on_cran()
p <- Problem(Minimize(norm2(c(3,4)) * a), list(a >= 2))
result <- solve(p)
expect_equal(result$value, 10, tolerance = TOL)
expect_equal(result$getValue(a), 2, tolerance = TOL)
})
test_that("Test recovery of dual variables", {
skip_on_cran()
for(solver in c("ECOS", "SCS", "CVXOPT")) {
if(solver %in% INSTALLED_SOLVERS) {
if(solver == "SCS")
acc <- 1e-1
else
acc <- 1e-5
p <- Problem(Minimize(p_norm(x + z, 1)), list(x >= c(2,3), cbind(c(1,2), c(3,4)) %*% z == c(-1,-4), p_norm(x + z, 2) <= 100))
result <- solve(p, solver = solver)
expect_equal(result$value, 4, tolerance = acc)
expect_equal(result$getValue(x), matrix(c(4,3)), tolerance = acc)
expect_equal(result$getValue(z), matrix(c(-4,1)), tolerance = acc)
expect_equal(result$getDualValue(p@constraints[[1]]), matrix(c(0,1)), tolerance = acc)
expect_equal(result$getDualValue(p@constraints[[2]]), matrix(c(-1,0.5)), tolerance = acc)
expect_equal(result$getDualValue(p@constraints[[3]]), 0, tolerance = acc)
Tmat <- matrix(1, nrow = 2, ncol = 3) * 2
c <- matrix(c(3,4), nrow = 1, ncol = 2)
p <- Problem(Minimize(1), list(A >= Tmat %*% C, A == B, C == t(Tmat)))
result <- solve(p, solver = solver)
expect_equal(result$getDualValue(p@constraints[[1]]), matrix(0, nrow = 2, ncol = 2), tolerance = acc)
expect_equal(result$getDualValue(p@constraints[[2]]), matrix(0, nrow = 2, ncol = 2), tolerance = acc)
expect_equal(result$getDualValue(p@constraints[[3]]), matrix(0, nrow = 3, ncol = 2), tolerance = acc)
}
}
})
test_that("Test problems with indexing", {
skip_on_cran()
p <- Problem(Maximize(x[1,1]), list(x[1,1] <= 2, x[2,1] == 3))
result <- solve(p)
expect_equal(result$value, 2, tolerance = TOL)
expect_equal(result$getValue(x), matrix(c(2,3)))
n <- 10
Aloc <- matrix(0:(n^2-1), nrow = n, ncol = n)
xloc <- Variable(n,n)
p <- Problem(Minimize(sum_entries(xloc)), list(xloc == Aloc))
result <- solve(p)
answer <- n*n*(n*n+1)/2 - n*n
expect_equal(result$value, answer)
obj <- A[1,1] + A[1,2] + A[2,2] + A[2,1]
p <- Problem(Maximize(obj), list(A <= rbind(c(1,-2), c(-3,4))))
result <- solve(p)
expect_equal(result$value, 0, tolerance = TOL)
expect_equal(result$getValue(A), rbind(c(1,-2), c(-3,4)))
exp <- cbind(c(1,2), c(3,4)) %*% z + x
p <- Problem(Minimize(exp[2,1]), list(x == z, z == c(1,2)))
result <- solve(p)
expect_equal(result$value, 12, tolerance = TOL)
expect_equal(result$getValue(x), result$getValue(z), tolerance = TOL)
})
test_that("Test problems with slicing", {
skip_on_cran()
p <- Problem(Maximize(sum_entries(C)), list(C[2:3,] <= 2, C[1,] == 1))
result <- solve(p)
expect_equal(result$value, 10, tolerance = TOL)
expect_equal(result$getValue(C), cbind(c(1,2,2), c(1,2,2)))
p <- Problem(Maximize(sum_entries(C[seq(1,3,2),2])), list(C[2:3,] <= 2, C[1,] == 1))
result <- solve(p)
expect_equal(result$value, 3, tolerance = TOL)
expect_equal(result$getValue(C[seq(1,3,2),2]), matrix(c(1,2)))
p <- Problem(Maximize(sum_entries((C[1:2,] + A)[,1:2])), list(C[2:3,] <= 2, C[1,] == 1, (A + B)[,1] == 3,
(A + B)[,2] == 2, B == 1))
result <- solve(p)
expect_equal(result$value, 12, tolerance = TOL)
expect_equal(result$getValue(C[1:2,]), cbind(c(1,2), c(1,2)), tolerance = TOL)
expect_equal(result$getValue(A), cbind(c(2,2),c(1,1)), tolerance = TOL)
p <- Problem(Maximize(matrix(c(3,4), nrow = 1, ncol = 2) %*% (C[1:2,] + A)[,1]),
list(C[2:3,] <= 2, C[1,] == 1, matrix(c(1,2), nrow = 1, ncol = 2) %*% (A + B)[,1] == 3,
(A + B)[,2] == 2, B == 1, 3*A[,1] <= 3))
result <- solve(p)
expect_equal(result$value, 12, tolerance = TOL)
expect_equal(result$getValue(C[1:2,1]), matrix(c(1,2)), tolerance = TOL)
expect_equal(result$getValue(A), cbind(c(1,-0.5), c(1,1)), tolerance = TOL)
p <- Problem(Minimize(norm2((C[1:2,] + A)[,1])), list(C[2:3,] <= 2, C[1,] == 1, (A + B)[,1] == 3, (A + B)[,2] == 2, B == 1))
result <- solve(p)
expect_equal(result$value, 3, tolerance = TOL)
expect_equal(result$getValue(C[1:2,1]), matrix(c(1,-2)), tolerance = 1e-4)
expect_equal(result$getValue(A), cbind(c(2,2), c(1,1)), tolerance = TOL)
p <- Problem(Maximize(sum_entries(C)), list(t(C[2:3,]) <= 2, t(C[1,]) == 1))
result <- solve(p)
expect_equal(result$value, 10, tolerance = TOL)
expect_equal(result$getValue(C), cbind(c(1,2,2), c(1,2,2)))
})
test_that("Test the vstack function", {
skip_on_cran()
c <- matrix(1, nrow = 1, ncol = 5)
p <- Problem(Minimize(c %*% vstack(x, y)), list(x == c(1,2), y == c(3,4,5)))
result <- solve(p)
expect_equal(result$value, 15, tolerance = TOL)
c <- matrix(1, nrow = 1, ncol = 4)
p <- Problem(Minimize(c %*% vstack(x, x)), list(x == c(1,2)))
result <- solve(p)
expect_equal(result$value, 6, tolerance = TOL)
c <- matrix(1, nrow = 2, ncol = 2)
p <- Problem(Minimize(sum_entries(vstack(A, C))), list(A >= 2*c, C == -2))
result <- solve(p)
expect_equal(result$value, -4, tolerance = TOL)
c <- matrix(1, nrow = 1, ncol = 2)
p <- Problem(Minimize(sum_entries(vstack(c %*% A, c %*% B))), list(A >= 2, B == -2))
result <- solve(p)
expect_equal(result$value, 0, tolerance = TOL)
c <- matrix(c(1,-1), nrow = 2, ncol = 1)
p <- Problem(Minimize(t(c) %*% vstack(a^2, sqrt(b))), list(a == 2, b == 16))
expect_error(solve(p))
})
test_that("Test the hstack function", {
skip_on_cran()
c <- matrix(1, nrow = 1, ncol = 5)
p <- Problem(Minimize(c %*% t(hstack(t(x), t(y)))), list(x == c(1,2), y == c(3,4,5)))
result <- solve(p)
expect_equal(result$value, 15, tolerance = TOL)
c <- matrix(1, nrow = 1, ncol = 4)
p <- Problem(Minimize(c %*% t(hstack(t(x), t(x)))), list(x == c(1,2)))
result <- solve(p)
expect_equal(result$value, 6, tolerance = TOL)
c <- matrix(1, nrow = 2, ncol = 2)
p <- Problem(Minimize(sum_entries(hstack(t(A), t(C)))), list(A >= 2*c, C == -2))
result <- solve(p)
expect_equal(result$value, -4, tolerance = TOL)
D <- Variable(3,3)
expr <- hstack(C, D)
p <- Problem(Minimize(expr[1,2] + sum_entries(hstack(expr, expr))), list(C >= 0, D >= 0, D[1,1] == 2, C[1,2] == 3))
result <- solve(p)
expect_equal(result$value, 13, tolerance = TOL)
c <- matrix(c(1,-1), nrow = 2, ncol = 1)
p <- Problem(Minimize(t(c) %*% t(hstack(t(a^2), t(sqrt(b))))), list(a == 2, b == 16))
expect_error(solve(p))
})
test_that("Test using a CVXR expression as an objective", {
skip_on_cran()
expect_error(Problem(x+2))
})
test_that("Test variable transpose", {
skip_on_cran()
p <- Problem(Minimize(sum_entries(x)), list(t(x) >= matrix(c(1,2), nrow = 1, ncol = 2)))
result <- solve(p)
expect_equal(result$value, 3, tolerance = TOL)
expect_equal(result$getValue(x), matrix(c(1,2)))
p <- Problem(Minimize(sum_entries(C)), list(matrix(c(1,1), nrow = 1, ncol = 2) %*% t(C) >= matrix(0:2, nrow = 1, ncol = 3)))
result <- solve(p)
value <- result$getValue(C)
constraints <- lapply(1:3, function(i) { 1*C[i,1] + 1*C[i,2] >= (i-1) })
p <- Problem(Minimize(sum_entries(C)), constraints)
result2 <- solve(p)
expect_equal(result$value, result2$value)
expect_equal(result$getValue(C), value)
p <- Problem(Minimize(A[1,2] - t(A)[2,1]), list(A == cbind(c(1,2), c(3,4))))
result <- solve(p)
expect_equal(result$value, 0, tolerance = TOL)
exp <- t(-x)
p <- Problem(Minimize(sum_entries(x)), list(t(-x) <= 1))
result <- solve(p)
expect_equal(result$value, -2, tolerance = TOL)
c <- matrix(c(1,-1), nrow = 2, ncol = 1)
p <- Problem(Minimize(max_elemwise(t(c), 2, 2 + t(c))[2]))
result <- solve(p)
expect_equal(result$value, 2, tolerance = TOL)
c <- cbind(c(1,-1,2), c(1,-1,2))
p <- Problem(Minimize(sum_entries(t(max_elemwise(c, 2, 2+c))[,1])))
result <- solve(p)
expect_equal(result$value, 6, tolerance = TOL)
c <- cbind(c(1,-1,2), c(1,-1,2))
p <- Problem(Minimize(sum_entries(t(t(c)^2)[,1])))
result <- solve(p)
expect_equal(result$value, 6, tolerance = TOL)
p <- Problem(Maximize(sum_entries(C)), list(t(C)[,2:3] <= 2, t(C)[,1] == 1))
result <- solve(p)
expect_equal(result$value, 10, tolerance = TOL)
expect_equal(result$getValue(C), cbind(c(1,2,2), c(1,2,2)))
})
test_that("Test multiplication on the left by a non-constant", {
skip_on_cran()
c <- matrix(c(1,2), nrow = 2, ncol = 1)
p <- Problem(Minimize(t(c) %*% A %*% c), list(A >= 2))
result <- solve(p)
expect_equal(result$value, 18, tolerance = TOL)
p <- Problem(Minimize(a*2), list(a >= 2))
result <- solve(p)
expect_equal(result$value, 4, tolerance = TOL)
p <- Problem(Minimize(t(x) %*% c), list(x >= 2))
result <- solve(p)
expect_equal(result$value, 6, tolerance = TOL)
p <- Problem(Minimize((t(x) + t(z)) %*% c), list(x >= 2, z >= 1))
result <- solve(p)
expect_equal(result$value, 9, tolerance = TOL)
})
test_that("Test redundant constraints", {
skip_on_cran()
obj <- Minimize(sum_entries(x))
constraints <- list(x == 2, x == 2, t(x) == 2, x[1] == 2)
p <- Problem(obj, constraints)
result <- solve(p, solver = "ECOS")
expect_equal(result$value, 4, tolerance = TOL)
obj <- Minimize(sum_entries(x^2))
constraints <- list(x == x)
p <- Problem(obj, constraints)
result <- solve(p, solver = "ECOS")
expect_equal(result$value, 0, tolerance = TOL)
})
test_that("Test that symmetry is enforced", {
skip_on_cran()
p <- Problem(Minimize(lambda_max(A)), list(A >= 2))
result <- solve(p)
expect_equal(result$getValue(A), t(result$getValue(A)), tolerance = 1e-3)
p <- Problem(Minimize(lambda_max(A)), list(A == cbind(c(1,2), c(3,4))))
result <- solve(p)
expect_equal(result$status, "infeasible")
})
test_that("Test SDP", {
skip_on_cran()
obj <- Maximize(A[2,1] - A[1,2])
p <- Problem(obj, list(lambda_max(A) <= 100, A[1,1] == 2, A[2,2] == 2, A[2,1] == 2))
result <- solve(p)
expect_equal(result$value, 0, tolerance = 1e-3)
})
test_that("Test getting values for expressions", {
skip_on_cran()
diff_exp <- x - z
inf_exp <- norm_inf(diff_exp)
sum_entries_exp <- 5 + p_norm(z,1) + p_norm(x,1) + inf_exp
constr_exp <- norm2(x + z)
obj <- norm2(sum_entries_exp)
p <- Problem(Minimize(obj), list(x >= c(2,3), z <= c(-1,-4), constr_exp <= 2))
result <- solve(p)
expect_equal(result$value, 22, tolerance = TOL)
expect_equal(result$getValue(x), matrix(c(2,3)), tolerance = TOL)
expect_equal(result$getValue(z), matrix(c(-1,-4)), tolerance = TOL)
xs <- result$getValue(x)
zs <- result$getValue(z)
expect_equal(result$getValue(diff_exp), xs - zs, tolerance = TOL)
expect_equal(result$getValue(inf_exp), norm(xs - zs, "I"))
expect_equal(result$getValue(sum_entries_exp), 5 + norm(zs, "1") + norm(xs, "1") + norm(xs - zs, "I"))
expect_equal(result$getValue(constr_exp), base::norm(xs + zs, "2"))
expect_equal(result$getValue(obj), result$value)
})
test_that("Test multiplication by zero", {
skip_on_cran()
exp <- 0*a
expect_equal(value(exp), matrix(0))
obj <- Minimize(exp)
p <- Problem(obj)
result <- solve(p)
expect_equal(result$value, 0, tolerance = TOL)
expect_false(is.na(result$getValue(a)))
})
test_that("Tests a problem with division", {
skip_on_cran()
obj <- Minimize(norm_inf(A/5))
p <- Problem(obj, list(A >= 5))
result <- solve(p)
expect_equal(result$value, 1, tolerance = TOL)
})
test_that("Tests problems with multiply", {
skip_on_cran()
c <- cbind(c(1,-1), c(2,-2))
expr <- multiply(c, A)
obj <- Minimize(norm_inf(expr))
p <- Problem(obj, list(A == 5))
result <- solve(p)
expect_equal(result$value, 10, tolerance = TOL)
expect_equal(result$getValue(expr), cbind(c(5,-5), c(10,-10)), tolerance = TOL)
c <- Matrix::sparseMatrix(i = c(1,2), j = c(1,1), x = c(1,2))
expr <- multiply(c, x)
obj <- Minimize(norm_inf(expr))
p <- Problem(obj, list(x == 5))
result <- solve(p)
expect_equal(result$value, 10, tolerance = TOL)
expect_equivalent(as.matrix(result$getValue(expr)), matrix(c(5,10)))
c <- cbind(c(1,-1), c(2,-2))
expr <- multiply(c, a)
obj <- Minimize(norm_inf(expr))
p <- Problem(obj, list(a == 5))
result <- solve(p)
expect_equal(result$value, 10, tolerance = TOL)
expect_equivalent(as.matrix(result$getValue(expr)), cbind(c(5,-5), c(10,-10)))
})
test_that("Tests that errors occur when you use an invalid solver", {
skip_on_cran()
expect_error(solve(Problem(Minimize(Bool())), solver = "ECOS"))
expect_error(solve(Problem(Minimize(lambda_max(a))), solver = "ECOS"))
expect_error(solve(Problem(Minimize(a)), solver = "SCS"))
})
test_that("Tests problems with reshape_expr", {
skip_on_cran()
expect_equal(value(reshape_expr(1,c(1,1))), matrix(1))
x <- Variable(4)
mat <- cbind(c(1,-1), c(2,-2))
vec <- matrix(1:4)
vec_mat <- cbind(c(1,2), c(3,4))
expr <- reshape_expr(x,c(2,2))
obj <- Minimize(sum_entries(mat %*% expr))
prob <- Problem(obj, list(x == vec))
result <- solve(prob)
expect_equal(result$value, sum(mat %*% vec_mat))
c <- 1:4
expr <- reshape_expr(A,c(4,1))
obj <- Minimize(t(expr) %*% c)
constraints <- list(A == cbind(c(-1,-2), c(3,4)))
prob <- Problem(obj, constraints)
result <- solve(prob)
expect_equal(result$value, 20, tolerance = TOL)
expect_equal(result$getValue(expr), matrix(c(-1,-2,3,4)))
expect_equal(result$getValue(reshape_expr(expr,c(2,2))), cbind(c(-1,-2), c(3,4)))
expr <- reshape_expr(C,c(2,3))
mat <- rbind(c(1,-1), c(2,-2))
C_mat <- rbind(c(1,4), c(2,5), c(3,6))
obj <- Minimize(sum_entries(mat %*% expr))
prob <- Problem(obj, list(C == C_mat))
result <- solve(prob)
reshaped = matrix(C_mat, nrow = 2, ncol = 3, byrow = FALSE)
expect_equal(result$value, sum(mat %*% reshaped), tolerance = TOL)
expect_equal(result$getValue(expr), reshaped, tolerance = TOL)
c <- cbind(c(1,-1), c(2,-2))
expr <- reshape_expr(c * a,c(1,4))
obj <- Minimize(expr %*% (1:4))
prob <- Problem(obj, list(a == 2))
result <- solve(prob)
expect_equal(result$value, -6, tolerance = TOL)
expect_equal(result$getValue(expr), 2*matrix(c, nrow = 1), tolerance = TOL)
expr <- reshape_expr(c * a,c(4,1))
obj <- Minimize(t(expr) %*% (1:4))
prob <- Problem(obj, list(a == 2))
result <- solve(prob)
expect_equal(result$value, -6, tolerance = TOL)
expect_equal(result$getValue(expr), 2*matrix(c, ncol = 1), tolerance = TOL)
})
test_that("Tests problems with vec", {
skip_on_cran()
c <- 1:4
expr <- vec(A)
obj <- Minimize(t(expr) %*% c)
constraints <- list(A == cbind(c(-1,-2), c(3,4)))
prob <- Problem(obj, constraints)
result <- solve(prob)
expect_equal(result$value, 20, tolerance = TOL)
expect_equal(result$getValue(expr), matrix(c(-1,-2,3,4)))
})
test_that("Test a problem with diag", {
skip_on_cran()
C <- Variable(3,3)
obj <- Maximize(C[1,3])
constraints <- list(diag(C) == 1, C[1,2] == 0.6, C[2,3] == -0.3, C == Variable(3, 3, PSD = TRUE))
prob <- Problem(obj, constraints)
result <- solve(prob)
expect_equal(result$value, 0.583151, tolerance = 1e-2)
})
test_that("Test interaction of caching with changing constraints", {
skip_on_cran()
prob <- Problem(Minimize(a), list(a == 2, a >= 1))
result <- solve(prob)
expect_equal(result$value, 2, tolerance = TOL)
prob@constraints[[1]] = (a == 1)
result <- solve(prob)
expect_equal(result$value, 1, tolerance = TOL)
})
test_that("Test positive definite constraints", {
skip_on_cran()
C <- Variable(3,3)
obj <- Maximize(C[1,3])
constraints <- list(diag(C) == 1, C[1,2] == 0.6, C[2,3] == -0.3, C == t(C), C %>>% 0)
prob <- Problem(obj, constraints)
result <- solve(prob)
expect_equal(result$value, 0.583151, tolerance = 1e-2)
C <- Variable(2,2)
obj <- Maximize(C[1,2])
constraints <- list(C == 1, C %>>% rbind(c(2,0), c(0,2)))
prob <- Problem(obj, constraints)
result <- solve(prob)
expect_equal(result$status, "infeasible")
C <- Variable(2, 2, symmetric = TRUE)
obj <- Minimize(C[1,1])
constraints <- list(C %<<% cbind(c(2,0), c(0,2)))
prob <- Problem(obj, constraints)
result <- solve(prob)
expect_equal(result$status, "unbounded")
})
test_that("Test the duals of PSD constraints", {
skip_on_cran()
C <- Variable(2, 2, symmetric = TRUE, name = "C")
obj <- Maximize(C[1,1])
constraints <- list(C %<<% cbind(c(2,0), c(0,2)))
prob <- Problem(obj, constraints)
result <- solve(prob, solver = "SCS")
expect_equal(result$value, 2, tolerance = 1e-4)
psd_constr_dual <- result$getDualValue(constraints[[1]])
C <- Variable(2, 2, symmetric = TRUE, name = "C")
X <- Variable(2, 2, PSD = TRUE)
obj <- Maximize(C[1,1])
constraints <- list(X == cbind(c(2,0), c(0,2)) - C)
prob <- Problem(obj, constraints)
result <- solve(prob, solver = "SCS")
expect_equal(result$getDualValue(constraints[[1]]), psd_constr_dual, tolerance = 1e-3)
C <- Variable(2, 2, symmetric = TRUE)
obj <- Maximize(C[1,2] + C[2,1])
constraints <- list(C %<<% cbind(c(2,0), c(0,2)), C >= 0)
prob <- Problem(obj, constraints)
result <- solve(prob, solver = "SCS")
expect_equal(result$value, 4, tolerance = 1e-3)
psd_constr_dual <- result$getDualValue(constraints[[1]])
C <- Variable(2, 2, symmetric = TRUE)
X <- Variable(2, 2, PSD = TRUE)
obj <- Maximize(C[1,2] + C[2,1])
constraints <- list(X == cbind(c(2,0), c(0,2)) - C, C >= 0)
prob <- Problem(obj, constraints)
result <- solve(prob, solver = "SCS")
expect_equal(result$getDualValue(constraints[[1]]), psd_constr_dual, tolerance = 1e-3)
})
test_that("Test geo_mean function", {
skip_on_cran()
x <- Variable(2)
cost <- geo_mean(x)
prob <- Problem(Maximize(cost), list(x <= 1))
result <- solve(prob)
expect_equal(result$value, 1, tolerance = TOL)
prob <- Problem(Maximize(cost), list(sum(x) <= 1))
result <- solve(prob)
expect_equal(result$getValue(x), matrix(c(0.5,0.5)), tolerance = TOL)
x <- Variable(3,3)
expect_error(geo_mean(x))
x <- Variable(3,1)
g <- geo_mean(x)
x <- Variable(1,5)
g <- geo_mean(x)
p <- c(0.07, 0.12, 0.23, 0.19, 0.39)
short_geo_mean <- function(x, p) {
p <- as.numeric(p)/sum(p)
x <- as.numeric(x)
prod(x^p)
}
x <- Variable(5)
prob <- Problem(Maximize(geo_mean(x, p)), list(sum(x) <= 1))
result <- solve(prob)
x <- as.numeric(result$getValue(x))
x_true <- p/sum(p)
expect_equal(result$value, result$getValue(geo_mean(x, p)), tolerance = TOL)
expect_equal(result$value, short_geo_mean(x, p), tolerance = TOL)
expect_equal(x, x_true, tolerance = 1e-3)
x <- Variable(5)
prob <- Problem(Maximize(geo_mean(x, p)), list(p_norm(x) <= 1))
result <- solve(prob)
x <- as.numeric(result$getValue(x))
x_true <- sqrt(p/sum(p))
expect_equal(result$value, result$getValue(geo_mean(x, p)), tolerance = 1e-3)
expect_equal(result$value, short_geo_mean(x, p), tolerance = 1e-3)
expect_equal(x, x_true, tolerance = 1e-3)
n <- 5
x_true <- rep(1,n)
x <- Variable(n)
result <- solve(Problem(Maximize(geo_mean(x)), list(x <= 1)))
xval <- as.numeric(result$getValue(x))
expect_equal(xval, x_true, tolerance = 1e-3)
args <- lapply(seq_len(n), function(ind) x[ind])
y <- do.call(vstack, args)
result <- solve(Problem(Maximize(geo_mean(y)), list(x <= 1)))
xval <- as.numeric(result$getValue(x))
expect_equal(xval, x_true, tolerance = 1e-3)
y <- do.call(hstack, args)
result <- solve(Problem(Maximize(geo_mean(y)), list(x <= 1)))
xval <- as.numeric(result$getValue(x))
expect_equal(xval, x_true, tolerance = 1e-3)
})
test_that("Test p_norm function", {
skip_on_cran()
x <- Variable(3, name = "x")
avec <- c(1.0, 2, 3)
for(p in c(1, 1.6, 1.3, 2, 1.99, 3, 3.7, Inf)) {
prob <- Problem(Minimize(p_norm(x, p = p)), list(t(x) %*% avec >= 1))
result <- solve(prob)
if(p == Inf)
x_true <- rep(1, length(avec))/sum(avec)
else if(p == 1) {
x_true <- c(0,0,1.0/3)
} else
x_true <- avec^(1.0/(p-1)) / as.numeric(avec %*% (avec^(1.0/(p-1))))
x_alg <- as.vector(result$getValue(x))
expect_equal(x_alg, x_true, tolerance = 1e-3)
expect_equal(result$value, .p_norm(x_alg, p), tolerance = TOL)
expect_equal(.p_norm(x_alg, p), result$getValue(p_norm(x_alg, p)))
}
})
test_that("Test p_norm concave", {
skip_on_cran()
x <- Variable(3, name = "x")
a <- c(-1.0, 2, 3)
for(p in c(-1, 0.5, 0.3, -2.3)) {
prob <- Problem(Minimize(sum_entries(abs(x-a))), list(p_norm(x,p) >= 0))
result <- solve(prob)
expect_equal(result$value, 1, tolerance = TOL)
}
a <- c(1.0, 2, 3)
for(p in c(-1, 0.5, 0.3, -2.3)) {
prob <- Problem(Minimize(sum_entries(abs(x-a))), list(p_norm(x,p) >= 0))
result <- solve(prob)
expect_equal(result$value, 0, tolerance = TOL)
}
})
test_that("Test power function", {
skip_on_cran()
x <- Variable()
prob <- Problem(Minimize(power(x, 1.7) + power(x, -2.3) - power(x, 0.45)))
result <- solve(prob)
xs <- result$getValue(x)
expect_true(abs(1.7*xs^0.7 - 2.3*xs^-3.3 - 0.45*xs^-0.55) <= 1e-3)
})
test_that("Test a problem with multiply by a scalar", {
skip_on_cran()
Tnum <- 10
Jnum <- 20
rvec <- matrix(stats::rnorm(Tnum*Jnum), nrow = Tnum, ncol = Jnum)
dy <- matrix(stats::rnorm(2*Tnum), nrow = 2*Tnum, ncol = 1)
theta <- Variable(Jnum)
delta <- 1e-3
loglambda <- rvec %*% theta
a <- multiply(dy[1:Tnum], loglambda)
b1 <- exp(loglambda)
b2 <- multiply(delta, b1)
cost <- -a + b1
cost <- -a + b2
prob <- Problem(Minimize(sum_entries(cost)))
result <- solve(prob, solver = "SCS")
obj <- Minimize(sum_entries(multiply(2, x)))
prob <- Problem(obj, list(x == 2))
result <- solve(prob)
expect_equal(result$value, 8, tolerance = TOL)
}) |
library(ncappc)
ncappc.db <- data.frame(TIME=c(0:10),CONC=c(0,1,2,3.5,3.6,3.2,2.4,1.6,1.3,1.1,0.8))
TIME <- ncappc.db$TIME
CONC <- ncappc.db$CONC
TIME.positive <- ncappc.db[ncappc.db$TIME >= 0,"TIME"]
CONC.positive <- ncappc.db[ncappc.db$CONC >= 0,"CONC"] |
reglca_bound_classprobs <- function(class_probs, min_class_probs=1e-4)
{
if (any(is.na(class_probs))){
TP <- length(class_probs)
class_probs <- rep(1/TP, TP)
}
ind <- class_probs < min_class_probs
if (sum(ind)>0){
class_probs[ind] <- min_class_probs
class_probs <- cdm_sumnorm(class_probs)
}
return(class_probs)
} |
restricted.residual.mean <- function(out,x=0,tau=10,iid=0)
{
if ((class(out)!='cox.aalen')
& (class(out)!='aalen')
& (class(out)!='survfit') )
stop ("Must be output from cox.aalen or aalen function\n")
if (class(out)=="survfit") {
fit.table <- as.matrix(summary(out, rmean=tau)$table)
if (ncol(fit.table)==1) fit.table <- t(fit.table)
ee <- fit.table[,"*rmean"]
se <- fit.table[,"*se(rmean)"]
variid <- diag(se^2)
S0t <- NULL
timetau <- NULL
}
if (class(out)=="cox.aalen") {
time <- out$cum[,1]
cumhaz <- out$cum[,2]
beta <- out$gamma
if (is.matrix(x)!=TRUE) x <- matrix(x,nrow=1)
timetau <- c(time[time<tau],tau)
RR <- c( exp( x %*% beta) )
cumhaz<- matrix(1,nrow=nrow(x)) %*% t(matrix(cumhaz,ncol=(ncol(out$cum)-1)))
S0 <- exp(-cumhaz*RR)
S0t <- Cpred(cbind(time,t(S0)),timetau,strict=FALSE)[,-1,drop=FALSE]
Lam0t <- Cpred(cbind(time,t(cumhaz)),timetau,strict=FALSE)[,-1,drop=FALSE]
ll <- length(timetau)
ee <- apply(diff(timetau)*S0t[-ll,,drop=FALSE],2,sum)
deet <- apply(Lam0t[-ll,]*diff(timetau)*S0t[-ll,,drop=FALSE],2,sum)
RRDeet <- RR* deet
nn <- nrow(out$gamma.iid)
etiid <- c()
if (iid==1) {
for (j in 1:nn) {
gamiid <- x %*% out$gamma.iid[j,]
gamiid <- RRDeet * gamiid
Biidj<-Cpred(cbind(time,out$B.iid[[j]]),timetau)[,2]
baseiid <- RR*
apply(diff(timetau)*S0t[-ll,,drop=FALSE]*Biidj[-ll],2,sum)
etiid <- rbind(etiid,c(gamiid+ baseiid))
}
variid <- t(etiid) %*% etiid
se <- diag(variid)^.5
} else { variid <- se <- NULL }
}
if (class(out)=="aalen")
{
time <- out$cum[,1]
cumhaz <- out$cum[,-1]
timetau <- c(time[time<tau],tau)
cumhaz<- as.matrix(x) %*% t(cumhaz)
S0 <- exp(-cumhaz)
S0t <- Cpred(cbind(time,t(S0)),timetau,strict=FALSE)[,-1,drop=FALSE]
Lam0t <- Cpred(cbind(time,t(cumhaz)),timetau)[,-1,drop=FALSE]
ll <- length(timetau)
ee <- apply(diff(timetau)*S0t[-ll,,drop=FALSE],2,sum)
deet <- apply(Lam0t[-ll,]*diff(timetau)*S0t[-ll,,drop=FALSE],2,sum)
RRDeet <- deet
nn <- length(out$B.iid)
etiid <- c()
if (iid==1) {
for (j in 1:nn) {
Biidj<-Cpred(cbind(time,out$B.iid[[j]]),timetau)[,-1]
Biidj<- t(x %*% t(Biidj))
baseiid <- apply(diff(timetau)*S0t[-ll,,drop=FALSE]*Biidj[-ll,],2,sum)
etiid <- rbind(etiid,c(baseiid))
}
variid <- t(etiid) %*% etiid
se <- diag(variid)^.5
} else { variid <- se <- NULL }
}
out <- list(mean=ee,var.mean=variid,se=se,S0tau=S0t,timetau=timetau)
class(out) <- "restricted.residual.mean"
return(out)
}
plot.restricted.residual.mean <- function(x,...)
{
matplot(x$timetau,x$S0tau,type="s")
}
summary.restricted.residual.mean <- function(object, digits=3,...)
{
if (!is.null(object$se)) {
out <- cbind(object$mean,object$se)
colnames(out) <- c("mean","se") } else {
out <- matrix(object$mean,ncol=1)
colnames(out) <- "mean"}
prmatrix(signif(out,digits))
cat("\n");
} |
context("match_output_arguments")
test_that("match_output_arguments works as expected", {
out <- rep(FALSE, 3)
names(out) <- c("fit", "plots", "samples")
expect_equal(match_output_arguments(supported_args = names(out)),
out)
out["plots"] <- TRUE
expect_equal(match_output_arguments("plots", supported_args = names(out)), out)
out["samples"] <- TRUE
expect_equal(match_output_arguments(c("plots", "samples"),
supported_args = names(out)), out)
expect_equal(match_output_arguments("p", supported_args = names(out)), out)
}) |
context('Test the countMissing function.')
test_that('countMissing counts and prints correct information.', {
set.seed(2)
A <- array(rnorm(10 * 20 * 3), dim = c(20, 3, 10))
A[c(3, 4, 5), , 1] <- NA
A[8, , 5] <- NA
miss <- countMissing(A)
expect_equal(miss, c(3, 0, 0, 0, 1, rep(0, 5)))
expect_message(countMissing(A), '^2\ ')
expect_message(countMissing(A), 'specimen 1 with 3 missing landmarks')
}) |
context("hm_name")
path <- system.file('extdata', package = 'hydrotoolbox')
guido <-
hm_create() %>%
hm_build(bureau = 'snih', path = path,
file_name = c('snih_hq_guido.xlsx',
'snih_qd_guido.xlsx'),
slot_name = c('hq', 'qd'),
by = c('none', 'day') )
test_that("obj bad entry", {
expect_error(
hm_name(obj = TRUE,
slot_name = 'qd',
col_name = 'q(m3/s)')
)
expect_error(
hm_name(obj = 1:10,
slot_name = 'qd',
col_name = 'q(m3/s)')
)
expect_error(
hm_name(obj = 'guido',
slot_name = 'qd',
col_name = 'q(m3/s)')
)
})
test_that("slot_name bad entry", {
expect_error(
hm_name(obj = guido,
slot_name = 'guido',
col_name = 'q(m3/s)')
)
expect_error(
hm_name(obj = guido,
slot_name = TRUE,
col_name = 'q(m3/s)')
)
expect_error(
hm_name(obj = guido,
slot_name = c('qd', 'hola'),
col_name = 'q(m3/s)')
)
expect_error(
hm_name(obj = guido,
slot_name = c('qd', 'swe'),
col_name = 'q(m3/s)')
)
expect_error(
hm_name(obj = guido,
slot_name = c('swe'),
col_name = 'q(m3/s)')
)
})
test_that("col_name bad entry", {
expect_error(
hm_name(obj = guido,
slot_name = 'qd',
col_name = TRUE)
)
expect_error(
hm_name(obj = guido,
slot_name = 'qd',
col_name = 1:10)
)
expect_error(
hm_name(obj = guido,
slot_name = 'qd',
col_name = guido)
)
expect_error(
hm_name(obj = guido,
slot_name = 'qd',
col_name = c('hi', 'bye'))
)
}) |
x <- c("2", "1", "10", NA, "10")
E(sort(x, numeric=TRUE), c("1", "2", "10", "10"))
E(sort(x, numeric=TRUE, na.last=TRUE), c("1", "2", "10", "10", NA))
E(xtfrm2(x, numeric=TRUE), c(2L, 1L, 3L, NA, 3L))
E(xtfrm2(as.integer(x)), as.integer(x))
E(xtfrm(as.integer(x)), as.integer(x)) |
silverman<-function(x)
{
abs(0.5*exp(-abs(x)/sqrt(2))*sin(abs(x)/sqrt(2)+pi/4))/1.140086
}
ker<-function(obs,bdl,lod)
{
n=length(lod)
h=1.059*sd(lod)*n^(-1/3)
wei=rep(1,length(obs))
censored<- !bdl
obs <- pmax(obs,lod)
ind<-order(obs)
data=cbind(obs,censored)
data=data[ind,]
obs=obs[ind]
we=wei[ind]
wd=lod[ind]
dn<-data[,2]
if(length(unique(obs))==length(obs)){
ttn=rep(1,length(obs))
een=dn
temp=t(kronecker(t(wd),rep(1,n))-wd)
temp=silverman( (temp/h) )
temp1=diag(dn)
temp2=upper.tri(matrix(1,n,n), diag =TRUE )+matrix(0,n,n)
temp3=matrix(1,n,n)
temp6=sapply(obs,FUN=function(x) obs>=x)+matrix(0,n,n)
num=temp%*%temp1
deno=temp%*%temp2
pro=1-(num/deno)
cond=t(apply(pro,1,function (x){
out=rev(cumprod(rev(x[2:n])))
out=c(out,1)
return(out)
} ))
prob=apply(cond,2,mean,na.rm=T)
temp7=matrix(diag(cond),n,n,byrow=FALSE)
temp8=lower.tri(matrix(1,n,n), diag =FALSE )+matrix(0,n,n)
temp9=matrix(prob,n,n,byrow=TRUE)
inter_var=temp8*temp7+temp2*cond
temp10=matrix(diag(cond),n,n,byrow=FALSE)
temp55=matrix(dn,n,n,byrow=FALSE)
variance<-cond-temp9-cond*((temp55*temp6)/(temp10)+1-(1/(inter_var)))
sd=sqrt(apply(variance^2,2,sum,na.rm=TRUE))/n
lower.cl=pmax(rep(0,n),prob-1.96*sd)
upper.cl=pmin(rep(1,n),prob+1.96*sd)
out<-cbind(unique.obs=obs,cdf=prob,se=sd,lower=lower.cl,upper=upper.cl)
}else{
unique.obs=unique(obs)
een=tn=en=ttn=rep(NA,length(unique.obs))
for (i in 1:length(unique.obs))
{
ttn[i]=sum(obs==unique.obs[i])
tn[i]=sum( we[obs==unique.obs[i]] )
indi=which(obs==unique.obs[i])
en[i]=sum(dn[indi]*we[indi])
een[i]=sum(dn[which(obs==unique.obs[i])])
}
record=rep(NA,length(unique.obs))
num=deno=temp.num=temp.deno=matrix(0,length(obs),length(unique.obs))
for(i in 1: length(obs)){
if(obs[i]<=max(unique.obs)){
record=min(which(unique.obs>=obs[i]))
temp.deno[i,record:length(unique.obs)]=1
if(dn[i]==1){
temp.num[i,record]=1
}
}
}
dist=t(kronecker(t(wd),rep(1,n))-wd)/h
temp=silverman(dist)
temp.num=temp.num
temp.deno=temp.deno
for(i in 1:length(lod))
{
for(j in 1:length(unique.obs))
{
num[i,j]=sum(temp[i,]*temp.num[,j])
deno[i,j]=sum(temp[i,]*temp.deno[,j])
}
}
pro=1-(num/deno)
cond=t(apply(pro,1,function (x){
out=rev(cumprod(rev(x[2:length(unique.obs)])))
out=c(out,1)
return(out)
} ))
prob=apply(cond,2,mean)
ind_lod=match(unique.obs,obs)
cond=cond[ind_lod,]
n1=length(ind_lod)
temp7=matrix(diag(cond),n1,n1,byrow=FALSE)
temp8=lower.tri(matrix(1,n1,n1), diag =FALSE )+matrix(0,n1,n1)
temp9=matrix(prob,n1,n1,byrow=TRUE)
temp2=upper.tri(matrix(1,n1,n1), diag =TRUE )+matrix(0,n1,n1)
inter_var=temp8*temp7+temp2*cond
temp10=matrix(diag(cond),n1,n1,byrow=FALSE)
temp55=matrix(een,n1,n1,byrow=FALSE)
temp6=sapply(unique.obs,FUN=function(x) unique.obs>=x)+matrix(0,n1,n1)
variance<-cond-temp9-cond*((temp55*temp6)/(temp10)+1-(1/(inter_var)))
sd=sqrt(apply(variance^2,2,sum,na.rm=TRUE))/n
lower.cl=pmax(rep(0,n1),prob-1.96*sd)
upper.cl=pmin(rep(1,n1),prob+1.96*sd)
out<-cbind(unique.obs=unique.obs,cdf=prob,se=sd,lower=lower.cl,upper=upper.cl)
}
return(out)
}
KRKM <- function(obs,bdl,lod,method='formula',b=1000) UseMethod("KRKM")
KRKM.default<-function(obs,bdl,lod,method='formula',b=1000)
{
formula=ker(obs,bdl,lod)
if(method=='formula'){
out=formula
}else if (method=='bootstrap'){
temp=matrix(NA,dim(formula)[1],b)
for(i in 1:b)
{
ind=sample(1:length(lod),replace=TRUE)
obs.b=obs[ind]
lod.b=lod[ind]
bdl.b=bdl[ind]
x=formula[,c(1,2)]
y=ker(obs.b,bdl.b,lod.b)[,c(1,2)]
temp[,i]=merge(x,y,by='obs',all.x=TRUE)[,3]
}
se=apply(temp,1,sd,na.rm=TRUE)
lower=pmax(rep(0,length(se)),out[,2]-1.96*se)
upper=pmin(rep(1,(length(se))),out[,2]+1.96*se)
var=cbind(se,lower,upper)
out=formula[,1:2]
out=cbind(out,var)
}
output=list()
output$unique.obs=out[,1]
output$cdf=out[,2]
output$se=out[,3]
output$lower=out[,4]
output$upper=out[,5]
class(output) <- 'KRKM'
output
}
plot.KRKM<-function(x,conf.int=TRUE,lty=1,col=1,lwd=1,xlim=NULL,ylim=NULL,log="x",xlab=NULL,ylab='CDF',...)
{
options( warn = -1 )
plot(x$unique.obs,x$cdf,type='s',col=col,lty=lty,log=log,ylab=ylab,xlab=xlab,lwd=lwd,xlim=xlim,ylim=ylim,...)
if(conf.int){
points(x$unique.obs,x$lower,type='s',col='black',lty=2,log="x",lwd=1)
points(x$unique.obs,x$upper,type='s',col='black',lty=2,log="x",lwd=1)
}
} |
local({
freqData <- as.data.frame(table(galton$child-mean(galton$child), galton$parent-mean(galton$parent)))
names(freqData) <- c("child", "parent", "freq")
plot(as.numeric(as.vector(freqData$parent)),
as.numeric(as.vector(freqData$child)),
pch = 21, col = "black", bg = "lightblue",
cex = .07 * freqData$freq, xlab = "parent-mean(parent)", ylab = "child-mean(child)",
main="Subtracting the means eliminates the intercept.")
abline(lm(I(child-mean(child)) ~ I(parent-mean(parent)) - 1, galton),col="blue",lwd=3)
abline(h=0, lwd=2)
abline(v=0, lwd=2)
text(0, .6, "The intercept is 0", col='red', pos=2)
points(rep(0,3), rep(0,3), cex=2:4, lwd=2, col='red')
}) |
pesticideTrendCalcs <- function(tndbeg, tndend, ctnd, pval, alpha, setnd, scl,
baseConc, mclass) {
if (mclass == 1) {
por <- tndend - tndbeg
ctndPYR <- 100 * (10 ^ ctnd - 1)
ctndPpor <- formatC(100 * ((10 ^ ctnd) ^ por) - 100 , digits = 4,
flag = "
cuciPpor <- formatC(100 * ((10 ^ (ctnd + qnorm(1 - alpha/2) * setnd) ) ^ por) -
100, digits = 4, flag = "
clciPpor <- formatC(100 * ((10 ^ (ctnd - qnorm(1 - alpha/2) * setnd) ) ^ por) -
100, digits = 4, flag = "
ctndOrigPORPercentBase <- formatC(baseConc * ((10 ^ ctnd) ^ por) - baseConc,
digits = 4, flag = "
cuciOrigPORPercentBase <- formatC(baseConc * (10 ^ (ctnd + qnorm(1 - alpha/2) *
setnd)) ^ por - baseConc,
digits = 4, flag = "
clciOrigPORPercentBase <- formatC(baseConc *
(10 ^ (ctnd - qnorm(1 - alpha/2) * setnd)) ^ por -
baseConc, digits = 4, flag = "
format = "f")
ctndlklhd <- round(1 - pval/2, digits = 4)
cat("\n")
trends <- c(alpha, round(baseConc, digits = 4), ctndPpor, cuciPpor, clciPpor,
ctndOrigPORPercentBase, cuciOrigPORPercentBase, clciOrigPORPercentBase,
ctndlklhd)
} else if (mclass == 2) {
} else {
mclassmes <- c("Invalid model class. Currently,
the only valid mclass options are numeric values of 1 or 2.")
stop(mclassmes)
}
return(as.numeric(trends))
} |
executeURL<-
function(fullURL, type){
resp <- getURL(fullURL)
out <- fromJSON(resp)
if(length(out) != 0){
if(class(out[[1]]) == 'list'){
if(type == 'm'){
out <- YoutheriaToDF(out)
out1 <- unique(out)
tab1 <- table(out$MeasurementSetID)
tab2 <- table(out1$MeasurementSetID)
dups <- as.numeric(names(tab1[!tab1==tab2]))
for(i in dups){
tempOut <- out1[out1$MeasurementSetID==i,]
tabTemp <- names(table(tempOut$ValueType)[table(tempOut$ValueType)>1])
for(j in tabTemp){
rnam <- row.names(out1[out1$MeasurementSetID==i & out1$ValueType==j,])
out1 <- out1[!row.names(out1) %in% rnam[2:length(rnam)],]
}
}
out <- out1
} else {
out <- ldply(out, data.frame, stringsAsFactors=FALSE)
}
} else {
out <- as.data.frame(out)
}
} else {
out <- NULL
}
return(out)
} |
library(oce)
if (file.exists("/data/nwatl")) {
test_that("webtide", {
path <- paste(getOption("webtide"), "/data/nwatl", sep="")
pattern <- "nwatl_ll.nod"
if (1 == length(list.files(path=path, pattern=pattern))) {
a <- webtide("predict", longitude=-63, latitude=44, plot=FALSE)
expect_equal(names(a), c("time", "elevation", "u", "v", "node", "basedir","region"))
b <- webtide("map", longitude=-63, latitude=44, plot=FALSE)
expect_equal(names(b), c("node", "latitude", "longitude"))
if (FALSE) {
expect_equal(head(a$elevation), c(-0.20609221409, -0.14463463411, -0.08172047958,
-0.01835870715, 0.04443627478, 0.10566059067))
expect_equal(head(a$u), c(0.0069110978571, 0.0053063933931, 0.0038722056401,
0.0026186134050, 0.0015517477196, 0.0006737364902))
expect_equal(head(a$v), c(0.04802913583, 0.04822143736, 0.04790889414,
0.04709160408, 0.04577651402, 0.04397733928))
}
}
})} |
targets::tar_test("tar_format_api()", {
expect_null(tar_format_api(x, 1))
})
targets::tar_test("tar_format()", {
f <- tar_format("file")
x <- f(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "file")
})
targets::tar_test("tar_rds() runs", {
targets::tar_script(list(tarchetypes::tar_rds(x, 0L)))
targets::tar_make(callr_function = NULL)
expect_equal(targets::tar_read(x), 0L)
})
targets::tar_test("tar_rds() with pattern", {
x <- tar_rds(x, 1, pattern = map(y))
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$dimensions, "y")
})
targets::tar_test("tar_url()", {
x <- tar_url(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "url")
})
targets::tar_test("tar_file()", {
x <- tar_file(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "file")
})
targets::tar_test("tar_rds()", {
x <- tar_rds(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "rds")
})
targets::tar_test("tar_qs()", {
x <- tar_qs(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "qs")
})
targets::tar_test("tar_format_feather()", {
x <- tar_format_feather(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "feather")
})
targets::tar_test("tar_parquet()", {
x <- tar_parquet(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "parquet")
})
targets::tar_test("tar_fst()", {
x <- tar_fst(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "fst")
})
targets::tar_test("tar_fst_dt()", {
x <- tar_fst_dt(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "fst_dt")
})
targets::tar_test("tar_fst_tbl()", {
x <- tar_fst_tbl(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "fst_tbl")
})
targets::tar_test("tar_keras()", {
x <- tar_keras(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "keras")
})
targets::tar_test("tar_torch()", {
x <- tar_torch(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "torch")
})
targets::tar_test("tar_aws_file()", {
x <- tar_aws_file(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "aws_file")
})
targets::tar_test("tar_aws_rds()", {
x <- tar_aws_rds(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "aws_rds")
})
targets::tar_test("tar_aws_qs()", {
x <- tar_aws_qs(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "aws_qs")
})
targets::tar_test("tar_format_aws_feather()", {
x <- tar_format_aws_feather(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "aws_feather")
})
targets::tar_test("tar_aws_parquet()", {
x <- tar_aws_parquet(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "aws_parquet")
})
targets::tar_test("tar_aws_fst()", {
x <- tar_aws_fst(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "aws_fst")
})
targets::tar_test("tar_aws_fst_dt()", {
x <- tar_aws_fst_dt(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "aws_fst_dt")
})
targets::tar_test("tar_aws_fst_tbl()", {
x <- tar_aws_fst_tbl(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "aws_fst_tbl")
})
targets::tar_test("tar_aws_keras()", {
x <- tar_aws_keras(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "aws_keras")
})
targets::tar_test("tar_aws_torch()", {
x <- tar_aws_torch(x, 0)
expect_true(inherits(x, "tar_target"))
expect_equal(x$settings$format, "aws_torch")
}) |
convert.image<- function(imgrgb, threshold=.5) {
warning("Use of convert.image(...) is deprecated!")
return(convertImage(imgrgb, threshold))
}
convertImage<- function(imgrgb, threshold=.5) {
img <- ifelse((imgrgb[,,1]+imgrgb[,,2]+imgrgb[,,3])/3>threshold,1,0)
return(img);
} |
ntip <- function(phy, node){
nmax <- Ntip(phy)
tips <- vector()
while ( length(node) > 0 ){
node <- phy$edge[phy$edge[, 1] %in% node, 2]
tips <- c(tips, node[node <= nmax])
node <- node[node > nmax]
}
length(tips)
} |
read_pvolfile <- function(file, param = c(
"DBZH", "DBZ", "VRADH", "VRAD", "TH", "T", "RHOHV",
"ZDR", "PHIDP", "CELL", "BIOLOGY", "WEATHER", "BACKGROUND"
),
sort = TRUE, lat, lon, height, elev_min = 0,
elev_max = 90, verbose = TRUE,
mount = dirname(file)) {
tryCatch(read_pvolfile_body(
file, param, sort, lat, lon,
height, elev_min, elev_max,
verbose, mount
),
error = function(err) {
rhdf5::h5closeAll()
stop(err)
}
)
}
read_pvolfile_body <- function(file, param = c(
"DBZH", "DBZ", "VRADH", "VRAD", "TH", "T", "RHOHV",
"ZDR", "PHIDP", "CELL", "BIOLOGY", "WEATHER", "BACKGROUND"
),
sort = TRUE, lat, lon, height, elev_min = 0,
elev_max = 90, verbose = TRUE,
mount = dirname(file)) {
if (!is.logical(sort)) {
stop("'sort' should be logical")
}
if (!missing(lat)) {
if (!is.numeric(lat) || lat < -90 || lat > 90) {
stop("'lat' should be numeric between -90 and 90 degrees")
}
}
if (!missing(lon)) {
if (!is.numeric(lon) || lat < -360 || lat > 360) {
stop("'lon' should be numeric between -360 and 360 degrees")
}
}
if (!missing(height)) {
if (!is.numeric(height) || height < 0) {
stop("'height' should be a positive number of meters above sea level")
}
}
cleanup <- FALSE
if (H5Fis_hdf5(file)) {
if (!is.pvolfile(file)) {
stop("Failed to read HDF5 file.")
}
} else {
if (verbose) {
cat("Converting using Docker...\n")
}
if (!.pkgenv$docker) {
stop(
"Requires a running Docker daemon.\nTo enable, start your ",
"local Docker daemon, and run 'check_docker()' in R\n"
)
}
file <- nexrad_to_odim_tempfile(file,
verbose = verbose,
mount = mount
)
if (!is.pvolfile(file)) {
file.remove(file)
stop("converted file contains errors")
}
cleanup <- TRUE
}
scans <- h5ls(file, recursive = FALSE)$name
scans <- scans[grep("dataset", scans)]
elevs <- sapply(
scans,
function(x) {
h5readAttributes(
file,
paste(x, "/where", sep = "")
)$elangle
}
)
scans <- scans[elevs >= elev_min & elevs <= elev_max]
h5struct <- h5ls(file)
h5struct <- h5struct[h5struct$group == "/", ]$name
attribs.how <- attribs.what <- attribs.where <- NULL
if ("how" %in% h5struct) {
attribs.how <- h5readAttributes(file, "how")
}
if ("what" %in% h5struct) {
attribs.what <- h5readAttributes(file, "what")
}
if ("where" %in% h5struct) {
attribs.where <- h5readAttributes(file, "where")
}
vol.lat <- c(attribs.where$lat)
vol.lon <- c(attribs.where$lon)
vol.height <- c(attribs.where$height)
if (is.null(vol.lat)) {
if (missing(lat)) {
if (cleanup) {
file.remove(file)
}
stop("latitude not found in file, provide 'lat' argument")
}
}
if (!missing(lat)) {
vol.lat <- lat
}
if (is.null(vol.lon)) {
if (missing(lon)) {
if (cleanup) {
file.remove(file)
}
stop("longitude not found in file, provide 'lon' argument")
}
}
if (!missing(lon)) {
vol.lon <- lon
}
if (is.null(vol.height)) {
if (missing(height)) {
if (cleanup) {
file.remove(file)
}
stop("antenna height not found in file, provide 'height' argument")
}
}
if (!missing(height)) {
vol.height <- height
}
geo <- list(lat = vol.lat, lon = vol.lon, height = vol.height)
datetime <- as.POSIXct(paste(attribs.what$date, attribs.what$time),
format = "%Y%m%d %H%M%S", tz = "UTC"
)
sources <- strsplit(attribs.what$source, ",")[[1]]
radar <- gsub("RAD:", "", sources[which(grepl("RAD:", sources))])
attribs.where$height <- vol.height
attribs.where$lat <- vol.lat
attribs.where$lon <- vol.lon
data <- lapply(
scans,
function(x) {
read_pvolfile_scan(file, x, param, radar, datetime, geo)
}
)
valid_scans <- which(!sapply(data, is.null))
assert_that(length(valid_scans) > 0, msg = paste("none of the requested scan parameters found in file", file))
if(length(valid_scans) < length(scans)){
warning(paste("ignoring",length(scans)-length(valid_scans),"scan(s) in file",file,"because requested scan parameter(s) are missing."))
}
data <- data[valid_scans]
if (sort) {
data <- data[order(sapply(data, get_elevation_angles))]
}
output <- list(
radar = radar, datetime = datetime, scans = data,
attributes = list(
how = attribs.how, what = attribs.what,
where = attribs.where
), geo = geo
)
class(output) <- "pvol"
if (cleanup) {
file.remove(file)
}
output
}
read_pvolfile_scan <- function(file, scan, param, radar, datetime, geo) {
h5struct <- h5ls(file)
h5struct <- h5struct[h5struct$group == paste("/", scan, sep = ""), ]$name
groups <- h5struct[grep("data", h5struct)]
if (length(param) == 1 && param == "all") {
allParam <- TRUE
} else {
allParam <- FALSE
}
if (!allParam) {
quantityNames <- sapply(
groups,
function(x) {
h5readAttributes(
file,
paste(scan, "/", x, "/what",
sep = ""
)
)$quantity
}
)
groups <- groups[quantityNames %in% param]
if (length(groups) == 0) {
return(NULL)
}
}
attribs.how <- attribs.what <- attribs.where <- NULL
if ("how" %in% h5struct) {
attribs.how <- h5readAttributes(file, paste(scan, "/how", sep = ""))
}
if ("what" %in% h5struct) {
attribs.what <- h5readAttributes(file, paste(scan, "/what", sep = ""))
}
if ("where" %in% h5struct) {
attribs.where <- h5readAttributes(file, paste(scan, "/where", sep = ""))
}
geo$elangle <- c(attribs.where$elangle)
geo$rscale <- c(attribs.where$rscale)
geo$ascale <- c(360 / attribs.where$nrays)
quantities <- lapply(
groups,
function(x) {
read_pvolfile_quantity(
file,
paste(scan, "/", x, sep = ""),
radar, datetime, geo
)
}
)
quantityNames <- sapply(quantities, "[[", "quantityName")
quantities <- lapply(quantities, "[[", "quantity")
names(quantities) <- quantityNames
output <- list(
radar = radar, datetime = datetime, params = quantities,
attributes = list(
how = attribs.how, what = attribs.what,
where = attribs.where
), geo = geo
)
class(output) <- "scan"
output
}
read_pvolfile_quantity <- function(file, quantity, radar, datetime, geo) {
data <- h5read(file, quantity)$data
storage.mode(data) <- "numeric"
attr <- h5readAttributes(file, paste(quantity, "/what", sep = ""))
data <- replace(data, data == as.numeric(attr$nodata), NA)
data <- replace(data, data == as.numeric(attr$undetect), NaN)
data <- as.numeric(attr$offset) + as.numeric(attr$gain) * data
if(attr$quantity == "RHOHV"){
data <- replace(data, data > 10, NaN)
}
class(data) <- c("param", class(data))
attributes(data)$radar <- radar
attributes(data)$datetime <- datetime
attributes(data)$geo <- geo
attributes(data)$param <- attr$quantity
list(quantityName = attr$quantity, quantity = data)
} |
source("ESEUR_config.r")
pal_col=rainbow(3)
rev_acc=read.csv(paste0(ESEUR_dir, "regression/coderev-acc_years.csv.xz"))
rev_acc$accuracy=rev_acc$accuracy*100
plot(rev_acc$years.in.security, rev_acc$accuracy, col=pal_col[2],
yaxs="i",
xlab="Years working in security",
ylab="Percentage of vulnerabilities detected\n")
year_span=0:8
loess_mod=loess(accuracy ~ years.in.security, data=rev_acc, span=0.9)
loess_pred=predict(loess_mod, newdata=data.frame(years.in.security=year_span))
lines(year_span, loess_pred, col=pal_col[3])
gl_mod=glm(accuracy ~ years.in.security, data=rev_acc)
y_pred=predict(gl_mod, newdata=list(years.in.security=year_span), type="response", se.fit=TRUE)
lines(year_span, y_pred$fit, col=pal_col[1]) |
context("tunnel_methods_tests")
SLAccount <- account()
test_that("canGetTunnels", {
tunnels <- getTunnels(SLAccount, "seleniumPipes")
expect_true(inherits(tunnels, "list"))
})
test_that("canGetTunnel", {
tunnels <- getTunnels(SLAccount, "seleniumPipes")
if(length(tunnels) > 0){
tunnel <- getTunnel(SLAccount, "seleniumPipes", tunnelID = tunnels[[1]])
expect_true(inherits(tunnel, "list"))
}
})
test_that("canDeleteTunnel", {
tunnels <- getTunnels(SLAccount, "seleniumPipes")
if(length(tunnels) > 0){
res <- deleteTunnel(SLAccount, "seleniumPipes", tunnelID = tunnels[[1]])
expect_true(res$result)
}
}
) |
get_fun <- function(x){
if( grepl("::", x, fixed = TRUE) ){
coumpounds <- strsplit(x, split = "::", x, fixed = TRUE)[[1]]
z <- getFromNamespace(coumpounds[2], ns = coumpounds[1] )
} else {
z <- getAnywhere(x)
if(length(z$objs) < 1){
stop("could not find any function named ", shQuote(z$name), " in loaded namespaces or in the search path. If the package is installed, specify name with `packagename::function_name`.")
}
}
z
}
file_with_meta_ext <- function(file, meta_ext, ext = tools::file_ext(file)) {
paste(tools::file_path_sans_ext(file),
".", meta_ext, ".", ext,
sep = ""
)
}
absolute_path <- function(x){
if (length(x) != 1L)
stop("'x' must be a single character string")
epath <- path.expand(x)
if( file.exists(epath)){
epath <- normalizePath(epath, "/", mustWork = TRUE)
} else {
if( !dir.exists(dirname(epath)) ){
stop("directory of ", x, " does not exist.", call. = FALSE)
}
cat("", file = epath)
epath <- normalizePath(epath, "/", mustWork = TRUE)
unlink(epath)
}
epath
}
tables_default_values <- list(
style = "Table",
layout = "autofit",
width = 1,
tab.lp = "tab:",
topcaption = FALSE,
caption = list(
style = "Table Caption",
pre = "Table ", sep = ": ",
tnd = 0,
tns = "-",
fp_text = fp_text_lite(bold = TRUE)
),
conditional = list(
first_row = TRUE,
first_column = FALSE,
last_row = FALSE,
last_column = FALSE,
no_hband = FALSE,
no_vband = TRUE
)
)
plots_default_values <- list(
style = "Figure",
align = "center",
fig.lp = "fig:",
topcaption = FALSE,
caption = list(
style = "Image Caption",
pre = "Figure ", sep = ": ",
tnd = 0,
tns = "-",
fp_text = fp_text_lite(bold = TRUE)
)
)
lists_default_values <- list(
ol.style = NULL,
ul.style = NULL
)
page_size_default_values <- list(
width = 8.3,
height = 11.7,
orient = "portrait"
)
page_mar_default_values <- list(
bottom = 1.25,
top = 1.25,
right = 0.5,
left = .5,
header = 0.5,
footer = 0.5,
gutter = 0.5
)
get_docx_uncached <- function() {
ref_docx <- read_docx(get_reference_value(format = "docx"))
ref_docx
}
get_reference_rdocx <- memoise(get_docx_uncached)
rdocx_document <- function(base_format = "rmarkdown::word_document",
tables = list(), plots = list(), lists = list(),
mapstyles = list(), page_size = list(), page_margins = list(),
reference_num = TRUE, ...) {
args <- list(...)
if(is.null(args$reference_docx)){
args$reference_docx <- system.file(
package = "officedown", "examples",
"bookdown", "template.docx"
)
}
if(!is.null(args$number_sections) && isTRUE(args$number_sections)){
args$number_sections <- FALSE
}
args$reference_docx <- absolute_path(args$reference_docx)
base_format_fun <- get_fun(base_format)
output_formats <- do.call(base_format_fun, args)
tables <- modifyList(tables_default_values, tables)
plots <- modifyList(plots_default_values, plots)
lists <- modifyList(lists_default_values, lists)
page_size <- modifyList(page_size_default_values, page_size)
page_margins <- modifyList(page_mar_default_values, page_margins)
output_formats$knitr$opts_chunk <- append(
output_formats$knitr$opts_chunk,
list(tab.cap.style = tables$caption$style,
tab.cap.pre = tables$caption$pre,
tab.cap.sep = tables$caption$sep,
tab.cap.tnd = tables$caption$tnd,
tab.cap.tns = tables$caption$tns,
tab.cap.fp_text = tables$caption$fp_text,
tab.lp = tables$tab.lp,
tab.topcaption = tables$topcaption,
tab.style = tables$style,
tab.width = tables$width,
first_row = tables$conditional$first_row,
first_column = tables$conditional$first_column,
last_row = tables$conditional$last_row,
last_column = tables$conditional$last_column,
no_hband = tables$conditional$no_hband,
no_vband = tables$conditional$no_vband,
fig.cap.style = plots$caption$style,
fig.cap.pre = plots$caption$pre,
fig.cap.sep = plots$caption$sep,
fig.cap.tnd = plots$caption$tnd,
fig.cap.tns = plots$caption$tns,
fig.cap.fp_text = plots$caption$fp_text,
fig.align = plots$align,
fig.style = plots$style,
fig.lp = plots$fig.lp,
fig.topcaption = plots$topcaption
)
)
if(is.null(output_formats$knitr$knit_hooks)){
output_formats$knitr$knit_hooks <- list()
}
output_formats$knitr$knit_hooks$plot <- plot_word_fig_caption
intermediate_dir <- "."
temp_intermediates_generator <- output_formats$intermediates_generator
output_formats$intermediates_generator <- function(...){
intermediate_dir <<- list(...)[[2]]
temp_intermediates_generator(...)
}
output_formats$post_knit <- function(
metadata, input_file, runtime, ...){
output_file <- file_with_meta_ext(input_file, "knit", "md")
output_file <- file.path(intermediate_dir, output_file)
content <- readLines(output_file)
content <- post_knit_caption_references(content, lp = tables$tab.lp)
content <- post_knit_caption_references(content, lp = plots$fig.lp)
content <- post_knit_std_references(content, numbered = reference_num)
content <- block_macro(content)
writeLines(content, output_file)
}
output_formats$post_processor <- function(metadata, input_file, output_file, clean, verbose) {
x <- officer::read_docx(output_file)
x <- process_images(x)
x <- process_links(x)
x <- process_embedded_docx(x)
x <- process_par_settings(x)
x <- process_list_settings(x, ul_style = lists$ul.style, ol_style = lists$ol.style)
x <- change_styles(x, mapstyles = mapstyles)
default_sect_properties <- prop_section(
page_size = page_size(
orient = page_size$orient,
width = page_size$width,
height = page_size$height),
type = "continuous",
page_margins = page_mar(
bottom = page_margins$bottom,
top = page_margins$top,
right = page_margins$right,
left = page_margins$left,
header = page_margins$header,
footer = page_margins$footer,
gutter = page_margins$gutter)
)
defaut_sect_headers <- xml_find_all(docx_body_xml(x), "w:body/w:sectPr/w:headerReference")
defaut_sect_headers <- lapply(defaut_sect_headers, as_xml_document)
defaut_sect_footers <- xml_find_all(docx_body_xml(x), "w:body/w:sectPr/w:footerReference")
defaut_sect_footers <- lapply(defaut_sect_footers, as_xml_document)
x <- body_set_default_section(x, default_sect_properties)
defaut_sect <- xml_find_first(docx_body_xml(x), "w:body/w:sectPr")
for(i in rev(seq_len(length(defaut_sect_footers)))){
xml_add_child(defaut_sect, defaut_sect_footers[[i]])
}
for(i in seq_len(length(defaut_sect_headers))){
xml_add_child(defaut_sect, defaut_sect_headers[[i]])
}
forget(get_reference_rdocx)
print(x, target = output_file)
output_file
}
output_formats$bookdown_output_format = 'docx'
output_formats
} |
context("check-output")
library(testthat)
library(overviewR)
test_that("overview_tab() returns a data frame", {
output_table <- overview_tab(dat = toydata, id = ccode, time = year)
expect_is(output_table, "data.frame")
})
test_that("overview_tab() returns a dataframe with correct number of rows", {
output_table <- overview_tab(dat = toydata, id = ccode, time = year)
expect_equal(nrow(output_table), length(unique(toydata$ccode)))
})
test_that("overview_tab() works on a dataframe that is already in the correct
format", {
df_com <- data.frame(
ccode = c(
rep("RWA", 4),
rep("AGO", 8),
rep("BEN", 2),
rep("GBR", 5),
rep("FRA", 3)
),
year =
c(
seq(1990, 1995),
seq(1990, 1992),
seq(1995, 1999),
seq(1991, 1999, by = 2),
seq(1993, 1999, by = 3)
))
output_table <- overview_tab(dat = df_com, id = ccode, time = year)
expect_equal(nrow(output_table), 5)
})
test_that("check output of overview_print", {
output_table <- overview_tab(dat = toydata, id = ccode, time = year)
input_output <- overview_print(output_table, save_out = FALSE)
testthat::expect_null(print(input_output))
})
test_that("check output of overview_print with save_out", {
testthat::skip_on_cran()
output_table <- overview_tab(dat = toydata, id = ccode, time = year)
temp <- tempfile()
on.exit(unlink(temp), add = TRUE)
tex_output <- overview_print(output_table, save_out = TRUE, path = temp,
file = "output.tex")
testthat::expect_null(print(tex_output))
})
test_that("check output of overview_print for crosstab", {
output_cross <- overview_crosstab(dat = toydata, id = ccode, time = year,
cond1 = population, cond2 = gdp,
threshold1 = 27000, threshold2 = 25000)
input_output <- overview_print(output_cross, crosstab = TRUE,
save_out = FALSE)
testthat::expect_null(print(input_output))
})
test_that("check output of overview_print for crosstab with save_out", {
testthat::skip_on_cran()
output_cross <- overview_crosstab(dat = toydata, id = ccode, time = year,
cond1 = population, cond2 = gdp,
threshold1 = 27000, threshold2 = 25000)
temp <- tempfile()
on.exit(unlink(temp), add = TRUE)
tex_output <- overview_print(output_cross, crosstab = TRUE, save_out = TRUE,
path = temp, file = "output.tex")
testthat::expect_null(print(tex_output))
})
test_that("Get an error message", {
df_combined <- data.frame(
countries = c(
rep("RWA", 4),
rep("AGO", 8),
rep("BEN", 2),
rep("GBR", 5),
rep("FRA", 3)
))
expect_error(overview_print(df_combined),
"Data frame requires two columns that represent the time and
scope dimension of the data")
})
test_that("Get a warning message", {
data_test <- data.frame(
countries = c("RWA", "BDI"),
years = c(1990, 2000)
)
expect_warning(overview_print(data_test))
})
test_that("overview_crosstab() returns a data frame", {
output_crosstab <- overview_crosstab(
dat = toydata,
cond1 = gdp,
cond2 = population,
threshold1 = 25000,
threshold2 = 27000,
id = ccode,
time = year
)
expect_is(output_crosstab, "data.frame")
})
test_that("overview_crosstab() works on a dataframe that is already in the
correct format", {
df_com <- data.frame(
ccode = c(
rep("RWA", 4),
rep("AGO", 8),
rep("BEN", 2),
rep("GBR", 5),
rep("FRA", 3)
),
year =
c(
seq(1990, 1993),
seq(1990, 1997),
seq(1995, 1996),
seq(1991, 1995),
seq(1993, 1999, by = 3)
),
population =
seq(1, 44, by = 2),
gdp =
seq(1, 44, by = 2))
output_cross <- overview_crosstab(dat = df_com, id = ccode,
time = year,
cond1 = population,
cond2 = gdp,
threshold1 = 20,
threshold2 = 10)
expect_equal(nrow(output_cross), 2)
})
test_that("check output of overview_na", {
plot_na <- overview_na(dat = toydata)
testthat::expect_is(plot_na, "ggplot")
plot_na_abs <- overview_na(dat = toydata, perc = FALSE)
testthat::expect_is(plot_na_abs, "ggplot")
})
test_that("check output of overview_heat", {
plot_heat <- overview_heat(toydata, ccode, year, perc = TRUE, exp_total = 12)
testthat::expect_is(plot_heat, "ggplot")
plot_heat_abs <- overview_heat(toydata, ccode, year, perc = FALSE)
testthat::expect_is(plot_heat_abs, "ggplot")
})
test_that("check output of overview_heat with label FALSE", {
plot_heat_no_lab <- overview_heat(toydata, ccode, year, perc = TRUE,
label = FALSE, exp_total = 12)
testthat::expect_is(plot_heat_no_lab, "ggplot")
})
test_that("check output of overview_heat with label FALSE and no perc", {
plot_heat_abs_lab_false <- overview_heat(toydata, ccode, year, perc = FALSE,
label = FALSE)
testthat::expect_is(plot_heat_abs_lab_false, "ggplot")
})
test_that("check output of overview_plot", {
plot <- overview_plot(dat = toydata, id = ccode, time = year)
testthat::expect_is(plot, "ggplot")
})
test_that("check output of overview_plot", {
plot <- overview_plot(dat = toydata, id = ccode, time = year, asc = FALSE)
testthat::expect_is(plot, "ggplot")
}) |
Reg_K1Q <- function(Y, mat, Z, dt,type){
M <- round(max(mat)/dt)
m <- round(min(mat)/dt)
b <- matrix(data=NA, ncol= ncol(Y) , nrow = M )
for(i in 1:ncol(Y)){
a <- stats::splinefun(mat, t(Y[,i]), method="fmm")
b[,i] <- t(a(seq(dt, M*dt, dt)))
}
R <- b
Bn <- stats::lm( Jmisc::demean(t(R))~ Jmisc::demean(t(Z))-1)$coefficients
Bn <- t(Bn)
h <- m
n <- as.matrix((2*m):M, nrow =(2*m):M , ncol=1)
d <- matrix(data=NA, ncol= ncol(Bn), nrow=nrow(n) )
for (j in 1:ncol(Bn)){
d[,j] <- (h/n)*Bn[h,j]
}
LHS <- Bn[n,] - d
RHS <- matrix(data=NA, ncol= ncol(Bn), nrow=nrow(n) )
for (j in 1:ncol(Bn)){
RHS[,j] <- (1-h/n)*Bn[n-h,j]
}
K1Qh <- mldivide(RHS,LHS)
K1Q <- suppressWarnings(powerplus::Matpow(K1Qh, numer=1, denom = h))
if (type == "Jordan"){
K1Q <- Convert2JordanForm(K1Q)
}
return(K1Q)
}
Convert2JordanForm <- function(K1XQ) {
x <- t(eigen(K1XQ)$values)
idx <- numeric(length(x))
for (j in 1:length(x)){
if (Im(x[j])==0){
idx [j] <- 1
} else{
idx [j] <- 0
}}
realx <- Re(x[which(idx==1)])
if (numel(realx)%%2==0){
lQ <- as.numeric(vector())
}else{
lQ <- realx[1]
realx <- realx[seqi(2,length(realx))]
}
for (h in seqi(1,numel(realx)/2)){
lQ <- rbind( lQ, 0.5*(realx[2*h-1]+realx[2*h]), (0.5*(realx[2*h-1]- realx[2*h]))^2)
}
imagx <- t(x[Im(x)!=0])
for (h in seqi(1,numel(imagx)/2)){
lQ <- rbind(lQ, Re(imagx[2*h-1]), -abs(Im(imagx[2*h-1]))^2)
}
N<- numel(lQ)
K1Q <- rbind(zeros(1,N), eye(N-1,N))
i0 <- 0
if (N%%2!=0){
K1Q[1] <- lQ[1]
lQ <- lQ[2:length(lQ)]
i0 <- 1
}
for (h in seqi(1,numel(lQ)/2)){
K1Q[i0+2*h-1,i0+2*h-1] <- lQ[2*h-1]
K1Q[i0+2*h,i0+2*h] <- lQ[2*h-1]
K1Q[i0+2*h-1,i0+2*h] <- lQ[2*h]
}
return(K1Q)
} |
ci <- function(x, ...) {
UseMethod("ci")
}
.ci_bayesian <- function(x, ci = 0.95, method = "ETI", effects = c("fixed", "random", "all"), component = c("conditional", "zi", "zero_inflated", "all"), parameters = NULL, verbose = TRUE, BF = 1, ...) {
if (tolower(method) %in% c("eti", "equal", "ci", "quantile")) {
return(eti(x, ci = ci, effects = effects, component = component, parameters = parameters, verbose = verbose, ...))
} else if (tolower(method) %in% c("bci", "bca", "bcai")) {
return(bci(x, ci = ci, effects = effects, component = component, parameters = parameters, verbose = verbose, ...))
} else if (tolower(method) %in% c("hdi")) {
return(hdi(x, ci = ci, effects = effects, component = component, parameters = parameters, verbose = verbose, ...))
} else if (tolower(method) %in% c("si")) {
return(si(x, BF = BF, effects = effects, component = component, parameters = parameters, verbose = verbose, ...))
} else {
stop("`method` should be 'ETI' (for equal-tailed interval),'HDI' (for highest density interval), `BCI` (for bias corrected and accelerated bootstrap intervals) or 'SI' (for support interval).")
}
}
ci.numeric <- function(x, ci = 0.95, method = "ETI", verbose = TRUE, BF = 1, ...) {
.ci_bayesian(x, ci = ci, method = method, verbose = verbose, BF = BF, ...)
}
ci.data.frame <- ci.numeric
ci.emmGrid <- function(x, ci = NULL, ...) {
if (!.is_baysian_emmeans(x)) {
if (!requireNamespace("parameters")) {
stop("'parameters' required for this function to work.")
}
if (is.null(ci)) ci <- 0.95
return(parameters::ci(model = x, ci = ci, ...))
}
if (is.null(ci)) ci <- 0.95
x <- insight::get_parameters(x)
ci(x, ci = ci, ...)
}
ci.emm_list <- ci.emmGrid
ci.sim.merMod <- function(x, ci = 0.95, method = "ETI", effects = c("fixed", "random", "all"),
parameters = NULL, verbose = TRUE, ...) {
.ci_bayesian(x, ci = ci, method = method, effects = effects, parameters = parameters, verbose = verbose, ...)
}
ci.sim <- function(x, ci = 0.95, method = "ETI", parameters = NULL, verbose = TRUE, ...) {
.ci_bayesian(x, ci = ci, method = method, parameters = parameters, verbose = verbose, ...)
}
ci.stanreg <- function(x, ci = 0.95, method = "ETI", effects = c("fixed", "random", "all"),
component = c("location", "all", "conditional", "smooth_terms", "sigma", "distributional", "auxiliary"),
parameters = NULL, verbose = TRUE, BF = 1, ...) {
.ci_bayesian(x, ci = ci, method = method, effects = effects, component = component, parameters = parameters, verbose = verbose, BF = BF, ...)
}
ci.brmsfit <- function(x, ci = 0.95, method = "ETI", effects = c("fixed", "random", "all"),
component = c("conditional", "zi", "zero_inflated", "all"),
parameters = NULL, verbose = TRUE, BF = 1, ...) {
.ci_bayesian(x, ci = ci, method = method, effects = effects, component = component, parameters = parameters, verbose = verbose, BF = BF, ...)
}
ci.stanfit <- ci.stanreg
ci.blavaan <- ci.stanreg
ci.BFBayesFactor <- ci.numeric
ci.MCMCglmm <- function(x, ci = 0.95, method = "ETI", verbose = TRUE, ...) {
nF <- x$Fixed$nfl
ci(as.data.frame(x$Sol[, 1:nF, drop = FALSE]), ci = ci, method = method, verbose = verbose, ...)
}
ci.bamlss <- function(x, ci = 0.95, method = "ETI", component = c("all", "conditional", "location"), verbose = TRUE, ...) {
component <- match.arg(component)
ci(insight::get_parameters(x, component = component), ci = ci, method = method, verbose = verbose, ...)
}
ci.bcplm <- function(x, ci = 0.95, method = "ETI", verbose = TRUE, ...) {
ci(insight::get_parameters(x), ci = ci, method = method, verbose = verbose, ...)
}
ci.blrm <- ci.bcplm
ci.mcmc <- ci.bcplm
ci.mcmc.list <- ci.bcplm
ci.BGGM <- ci.bcplm
ci.get_predicted <- ci.data.frame |
knitr::opts_chunk$set(
collapse = TRUE,
echo = FALSE,
comment = "
)
use_dt <- FALSE
if(requireNamespace("DT", quietly = TRUE)) use_dt <- TRUE
DT::datatable(nflreadr::dictionary_espn_qbr,
options = list(scrollX = TRUE, pageLength = 25),
filter = "top",
rownames = FALSE
) |
mc.spGini<-function(Nsim=99,Bandwidth,x,Coord.X,Coord.Y,WType='Binary')
{
SIM.m<-matrix(data=NA, nrow=Nsim, ncol=5)
Obs<-length(x)
Coords<-cbind(Coord.X,Coord.Y)
spGini.Obs<-spGini(Coords,Bandwidth,x,WType)
SG<-spGini.Obs[[3]]/spGini.Obs[[1]]
for(i in 1:Nsim){
spGini.SIM<-spGini(Coords[sample(nrow(Coords)),],Bandwidth,x,WType)
SIM.m[i,1]<-i
SIM.m[i,2]<-spGini.SIM[[2]]
SIM.m[i,3]<-spGini.SIM[[3]]
SIM.m[i,4]<-spGini.SIM[[3]] / spGini.SIM[[1]]
if (SIM.m[i,4]>=SG){
SIM.m[i,5]<-1}
else
{SIM.m[i,5]<-0}
}
C.test<-sum(SIM.m[,5])
if ((Nsim-C.test)< C.test) {C.test=Nsim-C.test}
pseudo.p<-(1+C.test)/(Nsim+1)
SIMs<-data.frame(SIM.ID=SIM.m[,1], SIM.gwGini= SIM.m[,2],SIM.nsGini=SIM.m[,3], SIM.SG=SIM.m[,4], SIM.Extr= SIM.m[,5])
return(list(SIM=SIMs,spGini.Observed=spGini.Obs,pseudo.p=pseudo.p))
} |
context("Tests for posterior_predict helper functions")
test_that("posterior_predict for location shift models runs without errors", {
ns <- 30
nobs <- 10
prep <- structure(list(ndraws = ns), class = "brmsprep")
prep$dpars <- list(
mu = matrix(rnorm(ns * nobs), ncol = nobs),
sigma = rchisq(ns, 3), nu = rgamma(ns, 4)
)
i <- sample(nobs, 1)
pred <- brms:::posterior_predict_gaussian(i, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_student(i, prep = prep)
expect_equal(length(pred), ns)
})
test_that("posterior_predict for various skewed models runs without errors", {
ns <- 50
nobs <- 2
prep <- structure(list(ndraws = ns), class = "brmsprep")
prep$dpars <- list(
sigma = rchisq(ns, 3), beta = rchisq(ns, 3),
mu = matrix(rnorm(ns * nobs), ncol = nobs),
alpha = rnorm(ns), ndt = 1
)
pred <- brms:::posterior_predict_lognormal(1, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_shifted_lognormal(1, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_exgaussian(1, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_skew_normal(1, prep = prep)
expect_equal(length(pred), ns)
})
test_that("posterior_predict for aysm_laplace models runs without errors", {
ns <- 50
prep <- structure(list(ndraws = ns), class = "brmsprep")
prep$dpars <- list(
sigma = rchisq(ns, 3),
quantile = rbeta(ns, 2, 1),
mu = matrix(rnorm(ns*2), ncol = 2),
zi = rbeta(ns, 10, 10)
)
pred <- brms:::posterior_predict_asym_laplace(1, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_zero_inflated_asym_laplace(1, prep = prep)
expect_equal(length(pred), ns)
})
test_that("posterior_predict for multivariate linear models runs without errors", {
ns <- 10
nvars <- 3
ncols <- 4
nobs <- nvars * ncols
Sigma = array(cov(matrix(rnorm(300), ncol = 3)), dim = c(3, 3, 10))
prep <- structure(list(ndraws = ns), class = "mvbrmsprep")
prep$mvpars <- list(
Mu = array(rnorm(ns*nobs*nvars), dim = c(ns, nobs, nvars)),
Sigma = aperm(Sigma, c(3, 1, 2))
)
prep$dpars <- list(nu = rgamma(ns, 5))
prep$data <- list(N = nobs, N_trait = ncols)
pred <- brms:::posterior_predict_gaussian_mv(1, prep = prep)
expect_equal(dim(pred), c(ns, nvars))
pred <- brms:::posterior_predict_student_mv(2, prep = prep)
expect_equal(dim(pred), c(ns, nvars))
})
test_that("posterior_predict for ARMA covariance models runs without errors", {
ns <- 20
nobs <- 15
prep <- structure(list(ndraws = ns), class = "brmsprep")
prep$dpars <- list(
mu = matrix(rnorm(ns*nobs), ncol = nobs),
sigma = rchisq(ns, 3),
nu = rgamma(ns, 5)
)
prep$ac <- list(
ar = matrix(rbeta(ns, 0.5, 0.5), ncol = 1),
ma = matrix(rnorm(ns, 0.2, 1), ncol = 1),
begin_tg = c(1, 5, 12), end_tg = c(4, 11, 15)
)
prep$data <- list(se = rgamma(ns, 10))
prep$family$fun <- "gaussian_time"
pred <- brms:::posterior_predict_gaussian_time(1, prep = prep)
expect_equal(length(pred), ns * 4)
prep$family$fun <- "student_time"
pred <- brms:::posterior_predict_student_time(2, prep = prep)
expect_equal(length(pred), ns * 7)
})
test_that("loglik for SAR models runs without errors", {
ns = 3
prep <- structure(list(ndraws = ns, nobs = 10), class = "brmsprep")
prep$dpars <- list(
mu = matrix(rnorm(30), nrow = ns),
nu = rep(2, ns),
sigma = rep(10, ns)
)
prep$ac <- list(lagsar = matrix(c(0.3, 0.5, 0.7)), Msar = diag(10))
pred <- brms:::posterior_predict_gaussian_lagsar(1, prep = prep)
expect_equal(dim(pred), c(3, 10))
pred <- brms:::posterior_predict_student_lagsar(1, prep = prep)
expect_equal(dim(pred), c(3, 10))
prep$ac$errorsar <- prep$ac$lagsar
prep$ac$lagsar <- NULL
pred <- brms:::posterior_predict_gaussian_errorsar(1, prep = prep)
expect_equal(dim(pred), c(3, 10))
pred <- brms:::posterior_predict_student_errorsar(1, prep = prep)
expect_equal(dim(pred), c(3, 10))
})
test_that("posterior_predict for FCOR models runs without errors", {
ns <- 3
nobs <- 10
prep <- structure(list(ndraws = ns, nobs = nobs), class = "brmsprep")
prep$dpars <- list(
mu = matrix(rnorm(nobs * ns), nrow = ns),
sigma = rep(1, ns), nu = rep(2, ns)
)
prep$ac <- list(Mfcor = diag(nobs))
pred <- brms:::posterior_predict_gaussian_fcor(1, prep = prep)
expect_equal(dim(pred), c(ns, nobs))
pred <- brms:::posterior_predict_student_fcor(1, prep = prep)
expect_equal(dim(pred), c(ns, nobs))
})
test_that("posterior_predict for count and survival models runs without errors", {
ns <- 25
nobs <- 10
trials <- sample(10:30, nobs, replace = TRUE)
prep <- structure(list(ndraws = ns, nobs = nobs), class = "brmsprep")
prep$dpars <- list(
eta = matrix(rnorm(ns*nobs), ncol = nobs),
shape = rgamma(ns, 4), xi = 0
)
prep$dpars$nu <- prep$dpars$sigma <- prep$dpars$shape + 1
prep$data <- list(trials = trials)
i <- sample(nobs, 1)
prep$dpars$mu <- brms:::inv_cloglog(prep$dpars$eta)
pred <- brms:::posterior_predict_binomial(i, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_discrete_weibull(i, prep = prep)
expect_equal(length(pred), ns)
prep$dpars$mu <- exp(prep$dpars$eta)
pred <- brms:::posterior_predict_poisson(i, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_negbinomial(i, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_negbinomial2(i, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_geometric(i, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_com_poisson(i, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_exponential(i, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_gamma(i, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_frechet(i, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_inverse.gaussian(i, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_gen_extreme_value(i, prep = prep)
expect_equal(length(pred), ns)
prep$family$link <- "log"
pred <- brms:::posterior_predict_weibull(i, prep = prep)
expect_equal(length(pred), ns)
})
test_that("posterior_predict for bernoulli and beta models works correctly", {
ns <- 17
nobs <- 10
prep <- structure(list(ndraws = ns, nobs = nobs), class = "brmsprep")
prep$dpars <- list(
mu = brms:::inv_logit(matrix(rnorm(ns * nobs * 2), ncol = 2 * nobs)),
phi = rgamma(ns, 4)
)
i <- sample(1:nobs, 1)
pred <- brms:::posterior_predict_bernoulli(i, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_beta(i, prep = prep)
expect_equal(length(pred), ns)
})
test_that("posterior_predict for circular models runs without errors", {
ns <- 15
nobs <- 10
prep <- structure(list(ndraws = ns, nobs = nobs), class = "brmsprep")
prep$dpars <- list(
mu = 2 * atan(matrix(rnorm(ns * nobs * 2), ncol = nobs * 2)),
kappa = rgamma(ns, 4)
)
i <- sample(seq_len(nobs), 1)
pred <- brms:::posterior_predict_von_mises(i, prep = prep)
expect_equal(length(pred), ns)
})
test_that("posterior_predict for zero-inflated and hurdle models runs without erros", {
ns <- 50
nobs <- 8
trials <- sample(10:30, nobs, replace = TRUE)
prep <- structure(list(ndraws = ns, nobs = nobs), class = "brmsprep")
prep$dpars <- list(
eta = matrix(rnorm(ns * nobs * 2), ncol = nobs * 2),
shape = rgamma(ns, 4), phi = rgamma(ns, 1),
zi = rbeta(ns, 1, 1), coi = rbeta(ns, 5, 7)
)
prep$dpars$hu <- prep$dpars$zoi <- prep$dpars$zi
prep$data <- list(trials = trials)
prep$dpars$mu <- exp(prep$dpars$eta)
pred <- brms:::posterior_predict_hurdle_poisson(1, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_hurdle_negbinomial(2, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_hurdle_gamma(5, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_zero_inflated_poisson(3, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_zero_inflated_negbinomial(6, prep = prep)
expect_equal(length(pred), ns)
prep$dpars$mu <- brms:::inv_logit(prep$dpars$eta)
pred <- brms:::posterior_predict_zero_inflated_binomial(4, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_zero_inflated_beta(8, prep = prep)
expect_equal(length(pred), ns)
pred <- brms:::posterior_predict_zero_one_inflated_beta(7, prep = prep)
expect_equal(length(pred), ns)
})
test_that("posterior_predict for ordinal models runs without erros", {
ns <- 50
nobs <- 8
nthres <- 3
ncat <- nthres + 1
prep <- structure(list(ndraws = ns, nobs = nobs), class = "brmsprep")
prep$dpars <- list(
mu = array(rnorm(ns * nobs), dim = c(ns, nobs)),
disc = rexp(ns)
)
prep$thres$thres <- array(0, dim = c(ns, nthres))
prep$data <- list(Y = rep(1:ncat, 2), ncat = ncat)
prep$family$link <- "logit"
prep$family$family <- "cumulative"
pred <- sapply(1:nobs, brms:::posterior_predict_cumulative, prep = prep)
expect_equal(dim(pred), c(ns, nobs))
prep$family$family <- "sratio"
pred <- sapply(1:nobs, brms:::posterior_predict_sratio, prep = prep)
expect_equal(dim(pred), c(ns, nobs))
prep$family$family <- "cratio"
pred <- sapply(1:nobs, brms:::posterior_predict_cratio, prep = prep)
expect_equal(dim(pred), c(ns, nobs))
prep$family$family <- "acat"
pred <- sapply(1:nobs, brms:::posterior_predict_acat, prep = prep)
expect_equal(dim(pred), c(ns, nobs))
prep$family$link <- "probit"
pred <- sapply(1:nobs, brms:::posterior_predict_acat, prep = prep)
expect_equal(dim(pred), c(ns, nobs))
})
test_that("posterior_predict for categorical and related models runs without erros", {
set.seed(1234)
ns <- 50
nobs <- 8
ncat <- 3
prep <- structure(list(ndraws = ns, nobs = nobs), class = "brmsprep")
prep$dpars <- list(
mu1 = array(rnorm(ns*nobs, 0, 0.1), dim = c(ns, nobs)),
mu2 = array(rnorm(ns*nobs, 0, 0.1), dim = c(ns, nobs))
)
prep$data <- list(Y = rep(1:ncat, 2), ncat = ncat)
prep$family <- categorical()
prep$refcat <- 1
pred <- sapply(1:nobs, brms:::posterior_predict_categorical, prep = prep)
expect_equal(dim(pred), c(ns, nobs))
prep$data$trials <- sample(1:20, nobs)
prep$family <- multinomial()
pred <- brms:::posterior_predict_multinomial(i = sample(1:nobs, 1), prep = prep)
expect_equal(dim(pred), c(ns, ncat))
prep$dpars$phi <- rexp(ns, 1)
prep$family <- dirichlet()
pred <- brms:::posterior_predict_dirichlet(i = sample(1:nobs, 1), prep = prep)
expect_equal(dim(pred), c(ns, ncat))
expect_equal(rowSums(pred), rep(1, nrow(pred)))
prep$family <- brmsfamily("dirichlet2")
prep$dpars$mu1 <- rexp(ns, 10)
prep$dpars$mu2 <- rexp(ns, 10)
prep$dpars$mu3 <- rexp(ns, 10)
pred <- brms:::posterior_predict_dirichlet2(i = sample(1:nobs, 1), prep = prep)
expect_equal(dim(pred), c(ns, ncat))
expect_equal(rowSums(pred), rep(1, nrow(pred)))
prep$family <- brmsfamily("logistic_normal")
prep$dpars <- list(
mu2 = rnorm(ns),
mu3 = rnorm(ns),
sigma2 = rexp(ns, 10),
sigma3 = rexp(ns, 10)
)
prep$lncor <- rbeta(ns, 2, 1)
pred <- brms:::posterior_predict_logistic_normal(i = sample(1:nobs, 1), prep = prep)
expect_equal(dim(pred), c(ns, ncat))
expect_equal(rowSums(pred), rep(1, nrow(pred)))
})
test_that("truncated posterior_predict run without errors", {
ns <- 30
nobs <- 15
prep <- structure(list(ndraws = ns, nobs = nobs), class = "brmsprep")
prep$dpars <- list(
mu = matrix(rnorm(ns * nobs), ncol = nobs),
sigma = rchisq(ns, 3)
)
prep$refcat <- 1
prep$data <- list(lb = sample(-(4:7), nobs, TRUE))
pred <- sapply(1:nobs, brms:::posterior_predict_gaussian, prep = prep)
expect_equal(dim(pred), c(ns, nobs))
prep$dpars$mu <- exp(prep$dpars$mu)
prep$data <- list(ub = sample(70:80, nobs, TRUE))
pred <- sapply(1:nobs, brms:::posterior_predict_poisson, prep = prep)
expect_equal(dim(pred), c(ns, nobs))
prep$data <- list(lb = rep(0, nobs), ub = sample(70:75, nobs, TRUE))
pred <- sapply(1:nobs, brms:::posterior_predict_poisson, prep = prep)
expect_equal(dim(pred), c(ns, nobs))
})
test_that("posterior_predict for the wiener diffusion model runs without errors", {
skip("skip as long as RWiener fails on R-devel for 3.6.0")
ns <- 5
nobs <- 3
prep <- structure(list(ndraws = ns, nobs = nobs), class = "brmsprep")
prep$dpars <- list(
mu = matrix(rnorm(ns * nobs), ncol = nobs),
bs = rchisq(ns, 3), ndt = rep(0.5, ns),
bias = rbeta(ns, 1, 1)
)
prep$data <- list(Y = abs(rnorm(ns)) + 0.5, dec = c(1, 0, 1))
i <- sample(1:nobs, 1)
expect_equal(nrow(brms:::posterior_predict_wiener(i, prep)), ns)
})
test_that("posterior_predict_custom runs without errors", {
ns <- 15
nobs <- 10
prep <- structure(list(ndraws = ns, nobs = nobs), class = "brmsprep")
prep$dpars <- list(
mu = matrix(rbeta(ns * nobs * 2, 1, 1), ncol = nobs * 2)
)
prep$data <- list(trials = rep(1, nobs))
prep$family <- custom_family(
"beta_binomial2", dpars = c("mu", "tau"),
links = c("logit", "log"), lb = c(NA, 0),
type = "int", vars = "trials[n]"
)
posterior_predict_beta_binomial2 <- function(i, prep) {
mu <- prep$dpars$mu[, i]
rbinom(prep$ndraws, size = prep$data$trials[i], prob = mu)
}
expect_equal(length(brms:::posterior_predict_custom(sample(1:nobs, 1), prep)), ns)
}) |
ASDC<- function(seqs,label=c()){
upto=TRUE
if(length(seqs)==1&&file.exists(seqs)){
seqs<-fa.read(seqs,alphabet="aa")
seqs_Lab<-alphabetCheck(seqs,alphabet = "aa",label)
seqs<-seqs_Lab[[1]]
label<-seqs_Lab[[2]]
}
else if(is.vector(seqs)){
seqs<-sapply(seqs,toupper)
seqs_Lab<-alphabetCheck(seqs,alphabet = "aa",label)
seqs<-seqs_Lab[[1]]
label<-seqs_Lab[[2]]
}
else {
stop("ERROR: Input sequence is not in the correct format. It should be a FASTA file or a string vector.")
}
flag=0
numSeqs=length(seqs)
rng<-sapply(seqs, nchar)
rng<-rng-1
featureMatrix <- matrix(0 , ncol = 400,nrow = numSeqs)
dipep<-nameKmer(k=2,type = "aa")
featName<-vector()
colnames(featureMatrix)<-dipep
tempname<-dipep
for(n in 1:numSeqs){
seq<-seqs[n]
seqChars<-unlist(strsplit(seq,split = ""))
lenSeq<-length(seqChars)
len<-rng[n]
for(i in 1:len){
nums<-i-1
temp1<-seqChars[1:(lenSeq-nums-1)]
temp2<-seqChars[((nums+1)+1):(lenSeq)]
kmers<-paste(temp1,temp2,sep = "")
tbkmers<-table(kmers)
nmtbkmers<-names(tbkmers)
tempvect<-vector(mode = "numeric",length = 400)
names(tempvect)<-tempname
tempvect[nmtbkmers]<-tbkmers
featureMatrix[n,]<-featureMatrix[n,]+tempvect
}
featureMatrix[n,]<-featureMatrix[n,]/sum(featureMatrix[n,])
}
if(length(label)==numSeqs){
featureMatrix<-as.data.frame(featureMatrix)
featureMatrix<-cbind(featureMatrix,label)
}
row.names(featureMatrix)<-names(seqs)
return(featureMatrix)
} |
NULL
summary.vreq_LdM<-function(object,...)
{
res<-list(class="vreq_LdM",
com=get_com(object),
comnull=get_comnull(object),
vr=get_vr(object))
class(res)<-c("summary_tsvr","list")
return(res)
}
print.vreq_LdM<-function(x,...)
{
cat(paste0("Object of class vreq_LdM:\n CVcom2: ",get_com(x),"\n CVpop2: ",get_comnull(x),"\n LdM vr: ",get_vr(x)))
}
set_com.vreq_LdM<-function(obj,newval)
{
stop("Error in set_com: vreq_LdM slots should not be changed individually")
}
set_comnull.vreq_LdM<-function(obj,newval)
{
stop("Error in set_comnull: vreq_LdM slots should not be changed individually")
}
set_vr.vreq_LdM<-function(obj,newval)
{
stop("Error in set_vr: vreq_LdM slots should not be changed individually")
}
get_com.vreq_LdM<-function(obj)
{
return(obj$com)
}
get_comnull.vreq_LdM<-function(obj)
{
return(obj$comnull)
}
get_vr.vreq_LdM<-function(obj)
{
return(obj$vr)
} |
knitr::opts_chunk$set(
collapse = TRUE,
comment = "
fig.path = "man/figures/",
dpi = 300,
fig.width = 5,
fig.height = 3
)
library(cusumcharter)
library(ggplot2)
test_vec <- c(1,1,2,3,5,7,11,7,5,7,8,9,5)
test_vec
test_vec <- c(1,1,2,3,5,7,11,7,5,7,8,9,5)
variances <- cusum_single(test_vec)
p <- qplot(y = variances)
p <- p + geom_line()
p + geom_hline(yintercept = 0)
p
variance_df <- cusum_single_df(test_vec)
variance_df
p <- qplot(y = variance_df$x)
p <- p + geom_line()
p <- p + geom_hline(yintercept = variance_df$target)
p
cs_data <- cusum_control(test_vec)
cs_data
cusum_control_plot(cs_data,xvar = obs)
cusum_control_plot(cs_data,xvar = obs, show_below = TRUE)
library(dplyr)
library(ggplot2)
library(cusumcharter)
testdata <- tibble::tibble(
N = c(-15L,2L,-11L,3L,1L,1L,-11L,1L,1L,
2L,1L,1L,1L,10L,7L,9L,11L,9L),
metric = c("metric1","metric1","metric1","metric1","metric1",
"metric1","metric1","metric1","metric1","metric2",
"metric2","metric2","metric2","metric2","metric2",
"metric2","metric2","metric2"))
datecol <- as.Date(c("2021-01-01","2021-01-02", "2021-01-03", "2021-01-04" ,
"2021-01-05", "2021-01-06","2021-01-07", "2021-01-08",
"2021-01-09"))
testres <- testdata %>%
dplyr::group_by(metric) %>%
dplyr::mutate(cusum_control(N)) %>%
dplyr::ungroup() %>%
dplyr::group_by(metric) %>%
dplyr::mutate(report_date = datecol) %>%
ungroup()
p5 <- cusum_control_plot(testres,
xvar = report_date,
show_below = TRUE,
facet_var = metric,
title_text = "Highlights above and below control limits")
p5 |
NULL
if(getRversion() >= "2.15.1") utils::globalVariables(c(".",
"descriptr", "dplyr", "ggplot2", "highcharter", "jsonlite", "lubridate",
"magrittr", "plotly", "purrr", "rbokeh", "readr", "readxl", "scales",
"shiny", "shinyBS", "shinythemes", "stringr", "tibble", "tidyr", "tools")) |
knitr::opts_chunk$set(
collapse = TRUE,
comment = "
)
library(fedmatch)
name_vec <- corp_data1[, Company]
name_vec
clean_strings(name_vec)
print(sp_char_words)
new_sp_char <- data.table::data.table(character = c("o"), replacement = c("apple"))
clean_strings(name_vec, sp_char_words = new_sp_char)
print(corporate_words[1:5])
clean_strings(name_vec, common_words = data.table::data.table(word = c("general", "almart"),
replacement = c("bananas", "oranges")))
word_frequency(sample(c("hi", "Hello", "bye "), 1e4, replace = TRUE))
clean_strings(name_vec, sp_char_words = new_sp_char, remove_char = c("a", "c"))
clean_strings(name_vec, common_words = data.table::data.table(word = c("general", "company"),
replacement = c("bananas", "oranges")),
remove_words = TRUE)
clean_strings(c( "call", "calling", "called"), stem = TRUE) |
zoom <- function(x, ...)
{
UseMethod("zoom")
}
zoom.trellis <- function(x, size=1, main=1.2*size, lab=size, axis=size,
strip=size, sub=0.9*size, legend=0.9*size,
splom=0.9*size, ...)
{
suppressWarnings({
if(!is.null(main)) x$main$cex <- main
if(!is.null(lab)) x$xlab$cex <- lab
if(!is.null(lab)) x$ylab$cex <- lab
if(!is.null(axis)) x$x.scales$cex <- rep(axis, length(x$x.scales$cex))
if(!is.null(axis)) x$y.scales$cex <- rep(axis, length(x$y.scales$cex))
if(!is.null(strip)) x$par.strip.text$cex <- strip
if(!is.null(sub)) x$sub$cex <- sub
if(!is.null(legend) && !is.null(x$legend))
{
side <- names(x$legend)[1]
x$legend[[side]]$args$key$cex.title <- legend
x$legend[[side]]$args$cex <- legend
x$legend[[side]]$args$key$cex <- legend
x$legend[[side]]$args$key$text$cex <- legend
}
if(!is.null(splom)) x$panel.args.common$varname.cex <- splom
})
print(x)
} |
AbForests_PlotGraphs<-function(graphs,no_arg,topdf,filename){
if(is.null((no_arg))){
temp<-graphs[sapply(graphs,function(x) "network" %in% names(x))]
if(length(temp)==0){
temp<-lapply(graphs,function(x) x[sapply(x,function(p) "network" %in% names(p))])
}
}else{
el_list<-sapply(graphs,function(x) x[no_arg])
temp<-el_list[sapply(el_list,function(x) "network" %in% names(x))]
if(length(el_list)==0){
temp<-lapply(el_list,function(x) x[sapply(x,function(p) "network" %in% names(p))])
}
}
if ("igraph" %in% unlist(lapply(temp,function(x) lapply(x,class))) || "igraph" %in% unlist(lapply(temp,function(x) lapply(x,function(a) lapply(a,class))))){
if(topdf==TRUE){
.WRITE_TO_PDF(filename)
lapply(temp, function(p){
if(is.null(p$network)){
p<-p[sapply(p,function(x) "network" %in% names(x))][[1]]
}
plot(p$network)
if (!is.null(p$legend)){
graphics::legend(p$legend[[1]],bty = p$legend[[2]],legend=p$legend[[3]],fill=p$legend[[4]],border=p$legend[[5]],inset=p$legend[[6]],xpd=p$legend[[7]],title=p$legend$title,cex=p$legend[[10]])
}
})
grDevices::dev.off()
}else{
lapply(temp, function(p){
if(is.null(p$network)){
p<-p[sapply(p,function(x) "network" %in% names(x))][[1]]
}
plot(p$network)
if (!is.null(p$legend)){
graphics::legend(p$legend[[1]],bty = p$legend[[2]],legend=p$legend[[3]],fill=p$legend[[4]],border=p$legend[[5]],inset=p$legend[[6]],xpd=p$legend[[7]],title=p$legend$title,cex=p$legend[[10]])
}
})
}
}else{
if(topdf==TRUE){
tryCatch(
expr = {
print_res<-lapply(graphs, function(x){
x[[no_arg]]})
gg_class<-c("gg","ggplot")
if(all(match( gg_class, unlist(lapply(print_res, class))))){
.WRITE_TO_PDF(filename)
invisible(lapply(print_res, print))
grDevices::dev.off()
}else{
stop('Error: Wrong arguments! Try again!')
}
},
error = function(e){
message('Error: Wrong arguments! Try again!')
}
)
}else{
tryCatch(
expr = {
print_res<-lapply(graphs, function(x){
x[[no_arg]]
})
},
error = function(e){
message('Error: Wrong arguments! Try again!')
}
)
}
}
} |
format_bytes <-
function (x, standard = "SI", digits = 1, width = 3, sep = " ")
{
if (any(x < 0))
stop("'x' must be positive")
if (standard == "SI") {
suffix <- c("B", "kB", "MB", "GB", "TB", "PB", "EB",
"ZB", "YB")
base <- 1000
}
else {
suffix <- c("B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
"ZiB", "YiB")
base <- 1024
}
.applyHuman <- function(x, base, suffix, digits, width, sep) {
n <- length(suffix)
for (i in 1:n) {
if (x >= base) {
if (i < n)
x <- x/base
}
else {
break
}
}
if (is.null(width)) {
x <- format(round(x = x, digits = digits), nsmall = digits)
}
else {
lenX <- nchar(x)
if (lenX > width) {
digitsMy <- width - (lenX - (lenX - (nchar(round(x)) +
1)))
digits <- ifelse(digitsMy > digits, digits, digitsMy)
}
if (i == 1)
digits <- 0
x <- round(x, digits = digits)
}
paste(x, suffix[i], sep = sep)
}
sapply(X = x, FUN = ".applyHuman", base = base, suffix = suffix,
digits = digits, width = width, sep = sep)
} |
JackSFRR = function (ysA, ysB, piA, piB, pik_ab_B, pik_ba_A, domainsA, domainsB, N_A, N_B, conf_level, sdA = "srs", sdB = "srs", strA = NULL, strB = NULL, clusA = NULL, clusB = NULL, fcpA = FALSE, fcpB = FALSE){
cnames <- names(ysA)
ysA <- as.matrix(ysA)
ysB <- as.matrix(ysB)
piA <- as.matrix(piA)
piB <- as.matrix(piB)
c <- ncol(ysA)
results <- matrix(NA, nrow = 6, ncol = c)
rownames(results) <- c("Total", "Jack Upper End", "Jack Lower End", "Mean", "Jack Upper End", "Jack Lower End")
colnames(results) <- cnames
estimation <- SFRR(ysA, ysB, piA, piB, pik_ab_B, pik_ba_A, domainsA, domainsB, N_A, N_B)
size_estimation <- estimation[[2]][1,1] / estimation[[2]][2,1]
if (!is.null(dim(drop(piA))))
pikA <- diag(piA)
else
pikA <- piA
if (!is.null(dim(drop(piB))))
pikB <- diag(piB)
else
pikB <- piB
if (sdA == "str"){
strataA <- unique(strA)
nhA <- table(strA)
nstrataA <- length(nhA)
YcstrataA <- matrix(0, nstrataA, c)
nhA <- c(0, nhA)
cnhA <- cumsum(nhA)
for (i in 1:nstrataA){
k <- 1
YcA <- matrix(0, nhA[i+1], c)
for (j in (cnhA[i]+1):cnhA[i+1]){
if (!is.null(dim(drop(piA))))
YcA[k,] <- SFRR(ysA[-j,], ysB, piA[-j,-j], piB, pik_ab_B[-j], pik_ba_A, domainsA[-j], domainsB, N_A, N_B)[[2]][1,]
else
YcA[k,] <- SFRR(ysA[-j,], ysB, piA[-j], piB, pik_ab_B[-j], pik_ba_A, domainsA[-j], domainsB, N_A, N_B)[[2]][1,]
k <- k + 1
}
YcAMean <- matrix(colMeans(YcA), nhA[i+1], c, byrow = TRUE)
if (fcpA)
fA <- 1 - mean(pikA[strA == strataA[i]])
else
fA <- 1
YcstrataA[i,] <- (nhA[i+1] - 1) / nhA[i+1] * fA * colSums((YcA - YcAMean)^2)
}
vjA <- colSums(YcstrataA)
}
else {
if (sdA == "clu"){
clustersA <- unique(clusA)
probclustersA <- unique(data.frame(pikA, clusA))[,1]
nclustersA <- length(clustersA)
if (nclustersA < 3)
stop("Number of clusters in frame A is less than 3. Variance cannot be computed.")
YcA <- matrix(0, nclustersA, c)
for (i in 1:nclustersA){
if (!is.null(dim(drop(piA))))
YcA[i,] <- SFRR(ysA[clusA %in% clustersA[-clustersA[i]],], ysB, piA[clusA %in% clustersA[-clustersA[i]],clusA %in% clustersA[-clustersA[i]]], piB, pik_ab_B[clusA %in% clustersA[-clustersA[i]]], pik_ba_A, domainsA[clusA %in% clustersA[-clustersA[i]]], domainsB, N_A, N_B)[[2]][1,]
else
YcA[i,] <- SFRR(ysA[clusA %in% clustersA[-clustersA[i]],], ysB, piA[clusA %in% clustersA[-clustersA[i]]], piB, pik_ab_B[clusA %in% clustersA[-clustersA[i]]], pik_ba_A, domainsA[clusA %in% clustersA[-clustersA[i]]], domainsB, N_A, N_B)[[2]][1,]
}
YcAMean <- matrix(colMeans(YcA), nclustersA, c, byrow = TRUE)
if (fcpA)
fA <- 1 - mean(probclustersA)
else
fA <- 1
vjA <- ((nclustersA - 1) / nclustersA) * fA * colSums ((YcA - YcAMean)^2)
}
else{
if (sdA == "strclu"){
strataA <- unique(strA)
nstrataA <- length(strataA)
nhA <- table(strA)
YcstrataA <- matrix(0, nstrataA, c)
nhA <- c(0,nhA)
cnhA <- cumsum(nhA)
for (i in 1:nstrataA){
clustersA <- unique(clusA[strA == strataA[i]])
probclustersA <- unique(data.frame(pikA[strA == strataA[i]], clusA[strA == strataA[i]]))[,1]
nclustersA <- length(clustersA)
if (nclustersA < 3)
stop("Number of clusters in any stratum from frame A is less than 3. Variance cannot be computed.")
k <- 1
YcA <- matrix(0, nclustersA, c)
for (j in 1:nclustersA){
if (!is.null(dim(drop(piA))))
YcA[k,] <- SFRR(ysA[clusA %in% clustersA[-clustersA[j]],], ysB, piA[clusA %in% clustersA[-clustersA[j]],clusA %in% clustersA[-clustersA[j]]], piB, pik_ab_B[clusA %in% clustersA[-clustersA[j]]], pik_ba_A, domainsA[clusA %in% clustersA[-clustersA[j]]], domainsB, N_A, N_B)[[2]][1,]
else
YcA[k,] <- SFRR(ysA[clusA %in% clustersA[-clustersA[j]],], ysB, piA[clusA %in% clustersA[-clustersA[j]]], piB, pik_ab_B[clusA %in% clustersA[-clustersA[j]]], pik_ba_A, domainsA[clusA %in% clustersA[-clustersA[j]]], domainsB, N_A, N_B)[[2]][1,]
k <- k + 1
}
YcAMean <- matrix(colMeans(YcA), nclustersA, c, byrow = TRUE)
if (fcpA)
fA <- 1 - mean(probclustersA)
else
fA <- 1
YcstrataA[i,] <- (nclustersA - 1) / nclustersA * fA * colSums((YcA - YcAMean)^2)
}
vjA <- colSums(YcstrataA)
}else{
nA <- nrow(ysA)
YcA <- matrix(0, nA, c)
for (i in 1:nA){
if (!is.null(dim(drop(piA))))
YcA[i,] <- SFRR(ysA[-i,], ysB, piA[-i,-i], piB, pik_ab_B[-i], pik_ba_A, domainsA[-i], domainsB, N_A, N_B)[[2]][1,]
else
YcA[i,] <- SFRR(ysA[-i,], ysB, piA[-i], piB, pik_ab_B[-i], pik_ba_A, domainsA[-i], domainsB, N_A, N_B)[[2]][1,]
}
YcAMean <- matrix(colMeans(YcA), nA, c, byrow = TRUE)
if (fcpA)
fA <- 1 - mean(pikA)
else
fA <- 1
vjA <- ((nA - 1) / nA) * fA * colSums ((YcA - YcAMean)^2)
}
}
}
if (sdB == "str"){
strataB <- unique(strB)
nhB <- table(strB)
nstrataB <- length(nhB)
YcstrataB <- matrix(0, nstrataB, c)
nhB <- c(0,nhB)
cnhB <- cumsum(nhB)
for (i in 1:nstrataB){
k <- 1
YcB <- matrix(0, nhB[i+1], c)
for (j in (cnhB[i]+1):cnhB[i+1]){
if (!is.null(dim(drop(piB))))
YcB[k,] <- SFRR(ysA, ysB[-j,], piA, piB[-j,-j], pik_ab_B, pik_ba_A[-j], domainsA, domainsB[-j], N_A, N_B)[[2]][1,]
else
YcB[k,] <- SFRR(ysA, ysB[-j,], piA, piB[-j], pik_ab_B, pik_ba_A[-j], domainsA, domainsB[-j], N_A, N_B)[[2]][1,]
k <- k + 1
}
YcBMean <- matrix(colMeans(YcB), nhB[i+1], c, byrow = TRUE)
if (fcpB)
fB <- 1 - mean(pikB[strB == strataB[i]])
else
fB <- 1
YcstrataB[i,] <- (nhB[i+1] - 1) / nhB[i+1] * fB * colSums((YcB - YcBMean)^2)
}
vjB <- colSums(YcstrataB)
}
else{
if (sdB == "clu"){
clustersB <- unique(clusB)
probclustersB <- unique(data.frame(pikB, clusB))[,1]
nclustersB <- length(clustersB)
if (nclustersB < 3)
stop("Number of clusters in frame B is less than 3. Variance cannot be computed.")
YcB <- matrix(0, nclustersB, c)
for (i in 1:nclustersB){
if (!is.null(dim(drop(piB))))
YcB[i,] <- SFRR(ysA, ysB[clusB %in% clustersB[-clustersB[i]],], piA, piB[clusB %in% clustersB[-clustersB[i]],clusB %in% clustersB[-clustersB[i]]], pik_ab_B, pik_ba_A[clusB %in% clustersB[-clustersB[i]]], domainsA, domainsB[clusB %in% clustersB[-clustersB[i]]], N_A, N_B)[[2]][1,]
else
YcB[i,] <- SFRR(ysA, ysB[clusB %in% clustersB[-clustersB[i]],], piA, piB[clusB %in% clustersB[-clustersB[i]]], pik_ab_B, pik_ba_A[clusB %in% clustersB[-clustersB[i]]], domainsA, domainsB[clusB %in% clustersB[-clustersB[i]]], N_A, N_B)[[2]][1,]
}
YcBMean <- matrix(colMeans(YcB), nclustersB, c, byrow = TRUE)
if (fcpB)
fB <- 1 - mean(probclustersB)
else
fB <- 1
vjB <- ((nclustersB - 1) / nclustersB) * fB * colSums ((YcB - YcBMean)^2)
}
else{
if(sdB == "strclu"){
strataB <- unique(strB)
nstrataB <- length(strataB)
nhB <- table(strB)
YcstrataB <- matrix(0, nstrataB, c)
nhB <- c(0, nhB)
cnhB <- cumsum(nhB)
for (i in 1:nstrataB){
clustersB <- unique(clusB[strB == strataB[i]])
probclustersB <- unique(data.frame(pikB[strB == strataB[i]], clusB[strB == strataB[i]]))[,1]
nclustersB <- length(clustersB)
if (nclustersB < 3)
stop("Number of clusters in any stratum from frame B is less than 3. Variance cannot be computed.")
k <- 1
YcB <- matrix(0, nclustersB, c)
for (j in 1:nclustersB){
if (!is.null(dim(drop(piB))))
YcB[k,] <- SFRR(ysA, ysB[clusB %in% clustersB[-clustersB[j]],], piA, piB[clusB %in% clustersB[-clustersB[j]],clusB %in% clustersB[-clustersB[j]]], pik_ab_B, pik_ba_A[clusB %in% clustersB[-clustersB[j]]], domainsA, domainsB[clusB %in% clustersB[-clustersB[j]]], N_A, N_B)[[2]][1,]
else
YcB[k,] <- SFRR(ysA, ysB[clusB %in% clustersB[-clustersB[j]],], piA, piB[clusB %in% clustersB[-clustersB[j]]], pik_ab_B, pik_ba_A[clusB %in% clustersB[-clustersB[j]]], domainsA, domainsB[clusB %in% clustersB[-clustersB[j]]], N_A, N_B)[[2]][1,]
k <- k + 1
}
YcBMean <- matrix(colMeans(YcB), nclustersB, c, byrow = TRUE)
if (fcpB)
fB <- 1 - mean(probclustersB)
else
fB <- 1
YcstrataB[i,] <- (nclustersB - 1) / nclustersB * fB * colSums((YcB - YcBMean)^2)
}
vjB <- colSums(YcstrataB)
}else{
nB <- nrow(ysB)
YcB <- matrix(0, nB, c)
for (i in 1:nB){
if (!is.null(dim(drop(piB))))
YcB[i,] <- SFRR(ysA[-i,], ysB, piA[-i,-i], piB, pik_ab_B[-i], pik_ba_A, domainsA[-i], domainsB, N_A, N_B)[[2]][1,]
else
YcB[i,] <- SFRR(ysA[-i,], ysB, piA[-i], piB, pik_ab_B[-i], pik_ba_A, domainsA[-i], domainsB, N_A, N_B)[[2]][1,]
}
YcBMean <- matrix(colMeans(YcB), nB, c, byrow = TRUE)
if (fcpB)
fB <- 1 - mean(pikB)
else
fB <- 1
vjB <- ((nB - 1) / nB) * fB * colSums((YcB - YcBMean)^2)
}
}
}
VJack_Yhat_SFRR <- vjA + vjB
results[1,] <- estimation[[2]][1,]
results[2,] <- estimation[[2]][1,] + qnorm(1 - (1 - conf_level) / 2) * sqrt(VJack_Yhat_SFRR)
results[3,] <- estimation[[2]][1,] - qnorm(1 - (1 - conf_level) / 2) * sqrt(VJack_Yhat_SFRR)
results[4,] <- estimation[[2]][2,]
results[5,] <- estimation[[2]][2,] + qnorm(1 - (1 - conf_level) / 2) * sqrt(1/size_estimation^2 * VJack_Yhat_SFRR)
results[6,] <- estimation[[2]][2,] - qnorm(1 - (1 - conf_level) / 2) * sqrt(1/size_estimation^2 * VJack_Yhat_SFRR)
return(results)
} |
plot.variogram.SpATS <-
function(x, min.length = 30, ...) {
values <- matrix(replace(x$data$value, x$data$length < min.length, NA), ncol = length(x$col.displacement), nrow = length(x$row.displacement), byrow = TRUE)
plot3Drgl::persp3Drgl(x$row.displacement, x$col.displacement, values, xlab = "Row displacement", ylab = "Col displacement", zlab = "", ticktype = "detailed", col = topo.colors(100))
} |
get_predict.clm <- function(model,
newdata = insight::get_data(model),
type = "response",
...) {
checkmate::assert_choice(type, choices = c("response", "prob"))
if (type == "response") {
type <- "prob"
}
resp <- insight::find_response(model)
newdata <- newdata[, setdiff(colnames(newdata), resp), drop = FALSE]
lhs <- names(attr(stats::terms(model), "dataClasses"))[1]
if (isTRUE(grepl("^factor\\(", lhs))) {
stop("The response variable should not be transformed to a factor in the formula. Please convert the variable to factor before fitting your model.")
}
pred <- stats::predict(model,
newdata = newdata,
type = type)$fit
out <- data.frame(
rowid = rep(1:nrow(pred), times = ncol(pred)),
group = rep(colnames(pred), each = nrow(pred)),
predicted = c(pred))
return(out)
}
get_group_names.clm <- get_group_names.polr |
pd_get_md <- function(pd) {
prism_check_dl_dir()
final_txt_full <- normalizePath(file.path(
prism_get_dl_dir(),
pd,
paste0(pd, ".info.txt")
))
if (length(final_txt_full) == 0) {
stop("No files exist to obtain metadata from.")
}
out <- lapply(1:length(final_txt_full), function(i) {
readin <- tryCatch(
utils::read.delim(
final_txt_full[i],
sep = "\n",
header = FALSE,
stringsAsFactors = FALSE
),
error = function(e) {
warning(e)
warning(paste0(
"Problem opening ",
final_txt_full[i],
". The folder may exist without the .info.text file inside it."
))
}
)
str_spl <- stringr::str_split(
as.character(readin[[1]]),
": ",
n = 2,
simplify = TRUE
)
names_md <- str_spl[, 1]
data_md <- str_spl[, 2]
out <- matrix(data_md, nrow = 1)
out <- as.data.frame(out, stringsAsFactors = FALSE)
names(out) <- names_md
out$file_path <- final_txt_full[i]
out$folder_path <- file.path(prism_get_dl_dir(), pd[i])
out
})
out <- dplyr::bind_rows(out)
if (all(colnames(out) %in% names(normals_name_map()))) {
colnames(out) <- normals_name_map()[colnames(out)]
out[["PRISM_DATASET_VERSION"]] <- NA
message(
"Renaming variables for normals to match those for other temporal periods.\n",
"See details in ?pd_get_md."
)
}
out
}
normals_name_map <- function() {
c(
"PRISM_FILENAME" = "PRISM_DATASET_FILENAME",
"PRISM_CREATE_DATE" = "PRISM_DATASET_CREATE_DATE",
"PRISM_DATASET" = "PRISM_DATASET_TYPE",
"PRISM_VERSION" = "PRISM_CODE_VERSION",
"PRISM_REMARKS" = "PRISM_DATASET_REMARKS",
"file_path" = "file_path",
"folder_path" = "folder_path"
)
} |
JRF_network <- function(out.jrf,out.perm,TH) {
nclasses<-dim(out.perm)[3]
M<-dim(out.perm)[2];
for (net in 1:nclasses) {
j.np<-sort(out.jrf[,2+net],decreasing=TRUE)
FDR<-matrix(0,dim(out.perm)[1],1);
for (s in 1:length(j.np)){
FP<-sum(sum(out.perm[,,net]>=j.np[s]))/M
FDR[s]<-FP/s;
if (FDR[s]>TH) {th<-j.np[s]; break;}
}
if (net==1) out<-list(out.jrf[out.jrf[,2+net]>th,seq(1,2)])
if (net>1) out<-list(out, out.jrf[out.jrf[,2+net]>th,seq(1,2)])
}
return(out)
} |
.plotEnv <- new.env()
.quantmodEnv <- new.env()
quantmodenv <- function() as.environment(".quantmodEnv")
print.quantmodEnv <- function(x, ...) {
print("<environment: quantmodEnv>")
}
.onAttach <- function(libname,pkgname) {
}
options(quantmod.deprecate.as.zoo.data.frame = TRUE)
setOldClass("zoo");
setOldClass("Date");
setClassUnion("xtsORzoo", c("xts","zoo"))
setClass("quantmod",representation(
model.id="character",
model.spec="formula",
model.formula="formula",
model.target="character",
model.inputs="character",
build.inputs="character",
symbols="character",
product="character",
price.levels="ANY",
training.data="ANY",
build.date="character",
fitted.model="ANY",
model.data="ANY",
quantmod.version="numeric"
)
);
setClass("quantmodReturn",representation(
results="xtsORzoo",
returns="xtsORzoo",
CAGR="numeric",
HPR="numeric",
accuracy="xtsORzoo",
directional.accuracy="list",
dist.of.returns="list",
returnsBy="ANY"
)
);
setMethod("show", "chobTA",
function(object) {
plot.chobTA(object)
}
)
setMethod("show","quantmod", function(object) {
cat("\nquantmod object: ",
[email protected],"\tBuild date: ",
paste([email protected]),"\n");
cat("\nModel Specified: \n ",
gsub("[ ]+"," ",deparse([email protected])),"\n");
cat("\nModel Target: ",[email protected],"\t\t",
"Product: ",object@product,"\n");
cat("Model Inputs: ",
paste([email protected],collapse=", "),"\n\n");
cat("Fitted Model: \n\n");
if(class([email protected])[1]=="NULL") {
cat("\tNone Fitted\n");
} else {
cat("\tModelling procedure: ",
class([email protected]),"\n");
cat("\tTraining window: ",
length([email protected])," observations from ",
paste([email protected][c(1,length([email protected]))],
collapse=" to "));
cat("\n")
print([email protected])
}
}
)
setMethod("summary","quantmod", function(object) {
cat("\nquantmod object: ",
[email protected],"\tBuild date: ",
paste([email protected]),"\n");
cat("\nModel Specified: \n ",
gsub("[ ]+"," ",deparse([email protected])),"\n");
cat("\nModel Target: ",[email protected],"\t\t",
"Product: ",object@product,"\n");
cat("Model Inputs: ",
paste([email protected],collapse=", "),"\n\n");
cat("Fitted Model: \n\n");
if(class([email protected])[1]=="NULL") {
cat("\tNone Fitted\n");
} else {
cat("\tModelling procedure: ",
class([email protected]),"\n");
cat("\tTraining window: ",
length([email protected])," observations from ",
paste([email protected][c(1,length([email protected]))],
collapse=" to "));
cat("\n")
summary([email protected])
}
})
"fittedModel"<-function(object) {[email protected]}
setGeneric("fittedModel<-", function(object,value) {standardGeneric("fittedModel<-")})
setReplaceMethod("fittedModel","quantmod", function(object,value)
{
[email protected] <- value
}
)
"predictModel" <-
function(object,data,...)
{
UseMethod("predictModel");
}
"predictModel.default" <-
function(object,data,...)
{
predict(object,data,...);
}
'plot.quantmodResults' <-
function(x,...)
{
ret.by <- x@return@returnsBy
plot(ret.by,type=c('l',rep('h',ncol(ret.by)-1)),...)
}
'formula.quantmod' <-
function(x,...)
{
[email protected]
}
'coef.quantmod' <-
function(object,...)
{
if(!is.null(fittedModel(object)))
coef(fittedModel(object),...)
}
'coefficients.quantmod' <- coef.quantmod
'fitted.quantmod' <-
function(object,...)
{
if(!is.null(fittedModel(object)))
fitted(fittedModel(object),...)
}
'fitted.values.quantmod' <- fitted.quantmod
'residuals.quantmod' <-
function(object,...)
{
if(!is.null(fittedModel(object)))
residuals(fittedModel(object,...))
}
'resid.quantmod' <- residuals.quantmod
'vcov.quantmod' <-
function(object,...)
{
if(!is.null(fittedModel(object)))
vcov(fittedModel(object,...))
}
'logLik.quantmod' <-
function(object, ...)
{
if(!is.null(fittedModel(object)))
logLik(fittedModel(object),...)
}
'anova.quantmod' <-
function(object,...)
{
if(!is.null(fittedModel(object)))
anova(fittedModel(object),...)
}
'plot.quantmod' <-
function(x,...)
{
if(!is.null(fittedModel(x)))
plot(fittedModel(x),...)
} |
'dse03bb' |
horizon <- function(h, r=6378137) {
x = cbind(as.vector(h), as.vector(r))
h = x[,1]
r = x[,2]
b = 0.8279
sqrt( 2 * r * h / b )
} |
distinfo <- function(obj,...){
UseMethod("distinfo")
}
basehazard <- function(obj,...){
UseMethod("basehazard")
}
gradbasehazard <- function(obj,...){
UseMethod("gradbasehazard")
}
hessbasehazard <- function(obj,...){
UseMethod("hessbasehazard")
}
cumbasehazard <- function(obj,...){
UseMethod("cumbasehazard")
}
gradcumbasehazard <- function(obj,...){
UseMethod("gradcumbasehazard")
}
hesscumbasehazard <- function(obj,...){
UseMethod("hesscumbasehazard")
}
densityquantile <- function(obj,...){
UseMethod("densityquantile")
}
distinfo.basehazardspec <- function(obj,...){
return(obj$distinfo)
}
basehazard.basehazardspec <- function(obj,...){
return(obj$basehazard)
}
gradbasehazard.basehazardspec <- function(obj,...){
return(obj$gradbasehazard)
}
hessbasehazard.basehazardspec <- function(obj,...){
return(obj$hessbasehazard)
}
cumbasehazard.basehazardspec <- function(obj,...){
return(obj$cumbasehazard)
}
gradcumbasehazard.basehazardspec <- function(obj,...){
return(obj$gradcumbasehazard)
}
hesscumbasehazard.basehazardspec <- function(obj,...){
return(obj$hesscumbasehazard)
}
densityquantile.basehazardspec <- function(obj,...){
return(obj$densityquantile)
} |
expect_grouping_works = function(r) {
data = insert_named(as.data.table(iris), list(grp = rep_len(letters[1:10], 150)))
task = TaskClassif$new("iris-grp", as_data_backend(data), target = "Species")
task$col_roles$group = "grp"
r$instantiate(task)
for (i in seq_len(r$iters)) {
expect_integer(r$train_set(i), lower = 1L, upper = 150L, any.missing = FALSE)
expect_integer(r$test_set(i), lower = 1L, upper = 150L, any.missing = FALSE)
if (!inherits(r, "ResamplingInsample")) {
expect_length(intersect(data[r$train_set(i), get("grp")], data[r$test_set(i), get("grp")]), 0L)
}
}
} |
test_that("oxford pet dataset", {
root <- tempfile()
train <- oxford_pet_dataset(
root = root,
download = TRUE,
transform = torchvision::transform_to_tensor,
target_transform = torchvision::transform_to_tensor
)
valid <- oxford_pet_dataset(
root = root,
split = "valid",
download = FALSE,
transform = torchvision::transform_to_tensor,
target_transform = torchvision::transform_to_tensor
)
expect_tensor_shape(train[1][[1]], c(3, 500, 394))
expect_tensor_shape(train[1][[2]], c(1, 500, 394))
expect_tensor_shape(valid[1][[1]], c(3, 225, 300))
expect_tensor_shape(valid[1][[2]], c(1, 225, 300))
}) |
context("PL 3: Calculate AUC (ROC) with the U statitics")
test_that("calc_auc_with_u() reterns a 'uauc' object", {
auc1 <- calc_auc_with_u(scores = c(0.1, 0.2, 0), labels = c(1, 0, 1))
data(P10N10)
sdat <- reformat_data(P10N10$scores, P10N10$labels, mode = "aucroc")
auc2 <- calc_auc_with_u(sdat)
auc3 <- calc_auc_with_u(scores = P10N10$scores, labels = P10N10$labels)
expect_true(is(auc1, "uauc"))
expect_true(is(auc2, "uauc"))
expect_true(is(auc3, "uauc"))
})
test_that("'sdat' must be a 'sdat' object", {
expect_err_msg <- function(sdat) {
err_msg <- "Unrecognized class for .validate()"
eval(bquote(expect_error(calc_auc_with_u(sdat), err_msg)))
}
expect_err_msg(list())
expect_err_msg(data.frame())
})
test_that("calc_auc_with_u() can directly take scores and labels", {
sdat <- reformat_data(c(0.1, 0.2, 0.2, 0), c(1, 0, 1, 1), mode = "aucroc")
auc1 <- calc_auc_with_u(sdat)
auc2 <- calc_auc_with_u(scores = c(0.1, 0.2, 0.2, 0),
labels = c(1, 0, 1, 1))
expect_equal(auc1, auc2)
})
test_that("calc_auc_with_u() accepts arguments for reformat_data()", {
err_msg <- "Invalid arguments: na.rm"
expect_error(calc_auc_with_u(scores = c(0.1, 0.2, 0.2, 0),
labels = c(1, 0, 1, 1), na.rm = TRUE),
err_msg)
aucs <- calc_auc_with_u(scores = c(0.1, 0.2, 0),
labels = c(1, 0, 1),
na_worst = TRUE,
ties_method = "first",
keep_sdat = TRUE)
expect_equal(.get_obj_arg(aucs, "sdat", "na_worst"), TRUE)
})
pl3_create_ms_dat <- function() {
s1 <- c(1, 2, 3, 4)
s2 <- c(5, 6, 7, 8)
s3 <- c(2, 4, 6, 8)
scores <- join_scores(s1, s2, s3)
l1 <- c(1, 0, 1, 1)
l2 <- c(0, 1, 1, 1)
l3 <- c(1, 1, 0, 1)
labels <- join_labels(l1, l2, l3)
list(scores = scores, labels = labels)
}
pl3_create_sm_dat <- function() {
s1 <- c(1, 2, 3, 4)
s2 <- c(5, 6, 7, 8)
s3 <- c(2, 4, 6, 8)
scores <- join_scores(s1, s2, s3)
l1 <- c(1, 0, 1, 1)
l2 <- c(0, 1, 1, 1)
l3 <- c(1, 1, 0, 1)
labels <- join_labels(l1, l2, l3)
list(scores = scores, labels = labels)
}
pl3_create_mm_dat <- function() {
s1 <- c(1, 2, 3, 4)
s2 <- c(5, 6, 7, 8)
s3 <- c(2, 4, 6, 8)
s4 <- c(2, 4, 6, 8)
scores <- join_scores(s1, s2, s3, s4)
l1 <- c(1, 0, 1, 1)
l2 <- c(0, 1, 1, 1)
l3 <- c(1, 1, 0, 1)
l4 <- c(1, 1, 0, 1)
labels <- join_labels(l1, l2, l3, l4)
list(scores = scores, labels = labels)
}
test_that("ss test data", {
scores <- c(1, 2, 3, 4)
labels <- c(1, 0, 1, 0)
curves <- evalmod(scores = scores, labels = labels)
aucs <- auc(curves)
aucs <- subset(aucs, curvetypes == "ROC")$aucs
uaucs1 <- calc_auc_with_u(scores = scores, labels = labels)
expect_equal(aucs, uaucs1$auc, tolerance = 1e-4)
uaucs2 <- calc_auc_with_u(scores = scores, labels = labels,
ustat_method = "sort")
expect_equal(aucs, uaucs2$auc, tolerance = 1e-4)
})
test_that("ms test data", {
msdat <- pl3_create_ms_dat()
scores <- msdat[["scores"]]
labels <- msdat[["labels"]]
curves <- evalmod(scores = scores, labels = labels)
aucs <- auc(curves)
aucs <- subset(aucs, curvetypes == "ROC")$aucs
for (i in seq_along(aucs)) {
s <- msdat[["scores"]][[i]]
l <- msdat[["labels"]][[i]]
uaucs1 <- calc_auc_with_u(scores = s, labels = l)
expect_equal(aucs[i], uaucs1$auc, tolerance = 1e-4)
uaucs2 <- calc_auc_with_u(scores = s, labels = l,
ustat_method = "sort")
expect_equal(aucs[i], uaucs2$auc, tolerance = 1e-4)
}
})
test_that("sm test data", {
smdat <- pl3_create_sm_dat()
scores <- smdat[["scores"]]
labels <- smdat[["labels"]]
curves <- evalmod(scores = scores, labels = labels)
aucs <- auc(curves)
aucs <- subset(aucs, curvetypes == "ROC")$aucs
for (i in seq_along(aucs)) {
s <- smdat[["scores"]][[i]]
l <- smdat[["labels"]][[i]]
uaucs1 <- calc_auc_with_u(scores = s, labels = l)
expect_equal(aucs[i], uaucs1$auc, tolerance = 1e-4)
uaucs2 <- calc_auc_with_u(scores = s, labels = l,
ustat_method = "sort")
expect_equal(aucs[i], uaucs2$auc, tolerance = 1e-4)
}
})
test_that("mm test data", {
mmdat <- pl3_create_mm_dat()
scores <- mmdat[["scores"]]
labels <- mmdat[["labels"]]
curves <- evalmod(scores = scores, labels = labels)
aucs <- auc(curves)
aucs <- subset(aucs, curvetypes == "ROC")$aucs
for (i in seq_along(aucs)) {
s <- mmdat[["scores"]][[i]]
l <- mmdat[["labels"]][[i]]
uaucs1 <- calc_auc_with_u(scores = s, labels = l)
expect_equal(aucs[i], uaucs1$auc, tolerance = 1e-4)
uaucs2 <- calc_auc_with_u(scores = s, labels = l,
ustat_method = "sort")
expect_equal(aucs[i], uaucs2$auc, tolerance = 1e-4)
}
}) |
barycenter_lp<-function(pos.list,weights.list,frechet.weights=NULL){
if (!requireNamespace("Rsymphony", quietly = TRUE)) {
warning("Package Rsymphony not detected: Please install Rsymphony for optimal performance if you are not using a Mac.")
Rsym<-FALSE
}
else{
Rsym<-TRUE
}
d<-dim(pos.list[[1]])[2]
sizes<-unlist(lapply(weights.list,length))
const<-(gen_constraints_multi(sizes))
bol_const<-const>0
rhs<-unlist(weights.list)
N<-length(pos.list)
if (is.null(frechet.weights)){
frechet.weights<-rep(1/N,N)
}
pos.full<-matrix(0,0,d)
for (i in 1:N){
pos.full<-rbind(pos.full,pos.list[[i]])
}
M<-prod(sizes)
cost<-NULL
for (k in 1:M){
mat<-pos.full[bol_const[,k],]
cost<-c(cost,euclid_bary_func_w(mat,frechet.weights))
}
if (Rsym){
out<-Rsymphony::Rsymphony_solve_LP(obj=cost,mat=const,dir=rep("==",length(rhs)),rhs=rhs,max=FALSE)
}
else{
out<-lpSolve::lp("min",cost,const,rep("==",length(rhs)),rhs)
}
inds<-out$solution>0
A.sub<-const[,inds]
out.pos<-matrix(0,0,d)
for (k in 1:(dim(A.sub)[2])){
pos<-A.sub[,k]>0
pos.sub<-diag(frechet.weights)%*%(pos.full[pos,])
out.pos<-rbind(out.pos,colSums(pos.sub))
}
weights.out<-out$sol[inds]
return(list(positions=out.pos,weights=weights.out))
} |
context("Testing extend_with")
test_that("Test extend_with", {
orig_list <- list(a = 1, b = 2)
new_list <- orig_list %>% extend_with(
"extension",
list(b = "3", c = list(1))
)
testthat::expect_is(new_list, "extension")
testthat::expect_is(new_list, "list")
testthat::expect_equal(length(new_list), 3)
testthat::expect_equal(new_list$a, 1)
testthat::expect_equal(new_list$b, "3")
testthat::expect_equal(new_list$c, list(1))
})
test_that("Test extend_with with ... functionality", {
orig_list <- list(a = 1, b = 2)
new_list <- orig_list %>% extend_with(
"extension2",
b = list(2),
c = "10"
)
testthat::expect_is(new_list, "extension2")
testthat::expect_is(new_list, "list")
testthat::expect_equal(length(new_list), 3)
testthat::expect_equal(new_list$a, 1)
testthat::expect_equal(new_list$b, list(2))
testthat::expect_equal(new_list$c, "10")
testthat::expect_error(
orig_list %>% extend_with(
"extension2",
"unnamed_variable"
)
)
}) |
context("heuristics_benchmark")
test_that("Benchmark ttbModel on city_population", {
ttb <- ttbModel(city_population, 3, c(4:ncol(city_population)))
times <- system.time(rowPairApply(city_population, heuristics(ttb)))
print("ttb")
print(times)
expect_lt(times[[2]], 1)
})
test_that("Benchmark regModel on city_population", {
reg <- regModel(city_population, 3, c(4:ncol(city_population)))
times <- system.time(rowPairApply(city_population, heuristics(reg)))
print("reg")
print(times)
expect_lt(times[[2]], 1)
}) |
BUGSmodel <- function(code,
name = NULL,
constants = list(),
dimensions = list(),
data = list(),
inits = list(),
returnModel = FALSE,
where = globalenv(),
debug = FALSE,
check = getNimbleOption('checkModel'),
calculate = TRUE,
userEnv = parent.frame()) {
nimbleModel(code = code,
constants = constants,
inits = inits,
dimensions = dimensions,
returnDef = !returnModel,
where = where,
debug = debug,
check = check,
calculate = calculate,
name = name,
userEnv = userEnv)
}
nimbleModel <- function(code,
constants = list(),
data = list(),
inits = list(),
dimensions = list(),
returnDef = FALSE,
where = globalenv(),
debug = FALSE,
check = getNimbleOption('checkModel'),
calculate = TRUE,
name = NULL,
userEnv = parent.frame()) {
returnModel <- !returnDef
if(is.null(name)) name <- paste0(gsub(" ", "_", substr(deparse(substitute(code))[1], 1, 10)),
'_',
nimbleModelID())
name <- gsub("::", "_cc_", name)
if(length(constants) && sum(names(constants) == ""))
stop("BUGSmodel: 'constants' must be a named list")
if(length(dimensions) && sum(names(dimensions) == ""))
stop("BUGSmodel: 'dimensions' must be a named list")
if(length(data) && sum(names(data) == ""))
stop("BUGSmodel: 'data' must be a named list")
if(any(!sapply(data, function(x) {
is.numeric(x) || is.logical(x) ||
(is.data.frame(x) && all(sapply(x, 'is.numeric'))) })))
stop("BUGSmodel: elements of 'data' must be numeric")
md <- modelDefClass$new(name = name)
if(nimbleOptions('verbose')) message("Defining model")
md$setupModel(code=code, constants=constants, dimensions=dimensions, inits = inits, data = data, userEnv = userEnv, debug=debug)
if(!returnModel) return(md)
if(debug) browser()
vars <- names(md$varInfo)
dataVarIndices <- names(constants) %in% vars & !names(constants) %in% names(data)
if(sum(names(constants) %in% names(data)))
message(" [Note] Found the same variable(s) in both 'data' and 'constants'; using variable(s) from 'data'.\n")
if(sum(dataVarIndices)) {
data <- c(data, constants[dataVarIndices])
}
if(nimbleOptions('verbose')) message("Building model")
model <- md$newModel(data=data, inits=inits, where=where, check=check, calculate = calculate, debug = debug)
return(model)
}
nimbleCode <- function(code) {
code <- substitute(code)
return(code)
}
BUGScode <- nimbleCode
processVarBlock <- function(lines) {
getDim <- function(vec) {
if(length(vec) > 1)
return(length(strsplit(vec[2], ";")[[1]])) else return(0)
}
getSize <- function(vec) {
if(length(vec) > 1)
return(strsplit(vec[2], ";")) else return("0")
}
lines <- gsub("
lines <- gsub(";", "", lines)
lines <- gsub("[[:space:]]", "", lines)
lines <- paste(lines, collapse = "")
chars <- strsplit(lines, integer(0))[[1]]
nch <- length(chars)
inBrackets <- FALSE
for(i in seq_len(nch)) {
if(inBrackets && chars[i] == ",")
chars[i] = ";"
if(chars[i] == "[") inBrackets <- TRUE
if(chars[i] == "]") inBrackets <- FALSE
}
lines <- paste(chars, collapse = "")
lines <- gsub("\\]", "", lines)
pieces <- unlist(strsplit(lines, ","))
pieces <- strsplit(pieces, "\\[")
varNames <- sapply(pieces, "[[", 1)
dim <- sapply(pieces, getDim)
size <- sapply(pieces, getSize)
names(dim) <- varNames
names(size) <- varNames
return(list(varNames = varNames, dim = dim, size = size))
}
processModelFile <- function(fileName) {
codeLines <- readLines(fileName)
codeLines <- paste(codeLines, collapse = "\n")
codeLines <- gsub("/\\*.*?\\*/", "", codeLines)
codeLines <- gsub("
codeLines <- paste("\n", codeLines, collapse = "")
varBlockRegEx = "\n\\s*var\\s*(\n*.*?)(\n+\\s*(data|model|const).*)"
dataBlockRegEx = "\n\\s*data\\s*\\{(.*?)\\}(\n+\\s*(var|model|const).*)"
modelBlockRegEx = "\n\\s*model\\s*\\{(.*?)\\}\\s*\n+\\s*(var|data|const).*"
if(length(grep(varBlockRegEx, codeLines))) {
varLines <- gsub(varBlockRegEx, "\\1", codeLines)
codeLines <- gsub(varBlockRegEx, "\\2", codeLines)
} else varLines = NULL
if(length(grep(dataBlockRegEx, codeLines))) {
dataLines <- gsub(dataBlockRegEx, "\\1", codeLines)
codeLines <- gsub(dataBlockRegEx, "\\2", codeLines)
} else dataLines = NULL
if(!length(grep(modelBlockRegEx, codeLines)))
modelBlockRegEx = "model\\s*\\{(.*?)\\}\\s*\n*\\s*$"
modelLines <- gsub(modelBlockRegEx, "\\1", codeLines)
modelLines <- paste("{\n", modelLines, "\n}\n", collapse = "")
return(list(modelLines = modelLines, varLines = varLines, dataLines = dataLines))
}
mergeMultiLineStatements <- function(text) {
text <- unlist( strsplit(text, "\n") )
firstNonWhiteSpaceIndex <- regexpr("[^[:blank:]]", text)
firstNonWhiteSpaceChar <- substr(text, firstNonWhiteSpaceIndex, firstNonWhiteSpaceIndex)
mergeUpward <- firstNonWhiteSpaceChar %in% c('+', '-', '*', '/')
if(length(text) > 1) {
for(i in seq.int(length(text), 2, by = -1)) {
if(mergeUpward[i]) {
text[i-1] <- paste(text[i-1], substring(text[i], firstNonWhiteSpaceIndex[i]) )
}
}
}
text <- text[!mergeUpward]
return(text)
}
processNonParseableCode <- function(text) {
text <- gsub("([^~]*)*~(.*?)\\)\\s*([TI])\\s*\\((.*)", "\\1~ \\3(\\2\\), \\4", text)
return(text)
}
readBUGSmodel <- function(model, data = NULL, inits = NULL, dir = NULL, useInits = TRUE, debug = FALSE, returnComponents = FALSE, check = getNimbleOption('checkModel'), calculate = TRUE) {
doEval <- function(vec, env) {
out <- rep(0, length(vec))
if(vec[1] == "0") return(numeric(0))
for(i in seq_along(vec))
out[i] <- eval(parse(text = vec[i]), env)
return(out)
}
skip.file.path <- is.null(dir) || (!is.null(dir) && dir == "")
modelFileOutput <- modelName <- NULL
if(is.function(model) || is.character(model)) {
if(is.function(model)) modelText <- mergeMultiLineStatements(deparse(body(model)))
if(is.character(model)) {
if(skip.file.path) modelFile <- model
else modelFile <- normalizePath(file.path(dir, model), winslash = "\\", mustWork=FALSE)
modelName <- gsub("\\..*", "", basename(model))
if(!file.exists(modelFile)) {
possibleNames <- c(paste0(modelFile, '.bug'), paste0(modelFile, '.txt'))
fileExistence <- file.exists(possibleNames)
if(!sum(fileExistence)) {
stop("readBUGSmodel: 'model' input does not reference an existing file.")
} else {
if(sum(fileExistence) > 1)
warning("readBUGSmodel: multiple possible model files; using .bug file.")
modelFile <- possibleNames[which(fileExistence)[1]]
}
}
modelFileOutput <- processModelFile(modelFile)
modelText <- mergeMultiLineStatements(modelFileOutput$modelLines)
}
modelText <- processNonParseableCode(modelText)
model <- parse(text = modelText)[[1]]
}
if(!inherits(model, "{"))
stop("readBUGSmodel: cannot process 'model' input.")
if(useInits) {
initsFile <- NULL
if(is.character(inits)) {
initsFile <- if(skip.file.path) inits else normalizePath(file.path(dir, inits), winslash = "\\", mustWork=FALSE)
if(!file.exists(initsFile))
stop("readBUGSmodel: 'inits' input does not reference an existing file.")
}
if(is.null(inits)) {
possibleNames <- paste0(modelName, c("-init.R", "-inits.R", "-init.txt", "-inits.txt", "-init", "inits"))
if(!Sys.info()['sysname'] %in% c("Darwin", "Windows"))
possibleNames <- c(possibleNames, paste0(modelName, c('-init.r','-inits.r')))
if(!skip.file.path) possibleNames <- normalizePath(file.path(dir, possibleNames), winslash = "\\", mustWork=FALSE)
fileExistence <- file.exists(possibleNames)
if(sum(fileExistence) > 1)
stop("readBUGSmodel: multiple possible initial value files; please pass as explicit 'inits' argument.")
if(sum(fileExistence))
initsFile <- possibleNames[which(fileExistence)[1]]
}
if(!is.null(initsFile)) {
inits <- new.env()
source(initsFile, inits)
inits <- as.list(inits)
}
} else inits <- NULL
if(is.null(inits)) inits <- list()
if(!is.list(inits))
stop("readBUGSmodel: invalid input for 'inits'.")
varInfo <- NULL
if(!is.null(modelFileOutput) && !is.null(modelFileOutput$varLines))
varInfo = processVarBlock(strsplit(modelFileOutput$varLines, "\n")[[1]])
dataFile <- NULL
if(is.character(data)) {
dataFile <- if(skip.file.path) data else normalizePath(file.path(dir, data), winslash = "\\", mustWork=FALSE)
if(!file.exists(dataFile))
stop("readBUGSmodel: 'data' input does not reference an existing file.")
}
if(is.null(data)) {
possibleNames <- paste0(modelName, c("-data.R", "-data.txt", "data"))
if(!Sys.info()['sysname'] %in% c("Darwin", "Windows"))
possibleNames <- c(possibleNames,
paste0(modelName, "-data.r"))
if(!skip.file.path) possibleNames <- normalizePath(file.path(dir, possibleNames), winslash = "\\", mustWork=FALSE)
fileExistence <- file.exists(possibleNames)
if(sum(fileExistence) > 1)
stop("readBUGSmodel: multiple possible initial value files; please pass as explicit 'data' argument.")
if(sum(fileExistence))
dataFile <- possibleNames[which(fileExistence)[1]]
}
if(!is.null(dataFile)) {
data <- new.env()
source(dataFile, data)
}
if(is.list(data)) {
if(length(data) && sum(names(data) == ""))
stop("readBUGSmodel: 'data' must be a named list")
data <- list2env(data)
}
if(!(is.null(data) || is.environment(data)))
stop("readBUGSmodel: invalid input for 'data'.")
if(!is.null(modelFileOutput) && !is.null(modelFileOutput$dataLines)) {
if(is.null(data))
data = new.env()
origVars <- ls(data)
vars <- varInfo$varNames[varInfo$dim > 0]
vars <- vars[!(vars %in% ls(data))]
for(thisVar in vars) {
dimInfo <- sapply(varInfo$size[[thisVar]], function(x) eval(parse(text = x), envir = data))
tmp <- 0
length(tmp) <- prod(dimInfo)
dim(tmp) <- dimInfo
assign(thisVar, tmp, envir = data)
}
eval(parse(text = modelFileOutput$dataLines), envir = data)
newVars <- nf_assignmentLHSvars(parse(text = modelFileOutput$dataLines)[[1]])
data <- as.list(data)[c(origVars, newVars)]
} else {
data <- as.list(data)
}
dims <- lapply(data, dimOrLength, scalarize = TRUE)
if(!is.null(varInfo)) {
env <- data
sizeInfo <- lapply(varInfo$size, doEval, env)
newNames <- names(sizeInfo)[!(names(sizeInfo) %in% names(data))]
dims[newNames] <- sizeInfo[newNames]
}
if(length(dims) && sum(names(dims) == ""))
stop("readBUGSmodel: something is wrong; 'dims' object is not a named list")
if(returnComponents){
return( list(modelName = modelName, code = model, dims = dims, data = data, inits = inits) )
}
Rmodel <- nimbleModel(code = model, name = ifelse(is.null(modelName), 'model', modelName), constants = data, dimensions = dims, inits = inits, debug = debug, check = check, calculate = calculate)
if(FALSE) {
dataNodes <- names(data)[(names(data) %in% Rmodel$getVarNames())]
data <- data[dataNodes]
names(data) <- dataNodes
Rmodel$setData(data)
if(!is.null(inits)) {
varNames <- names(inits)[names(inits) %in% Rmodel$getVarNames()]
for(varName in varNames) {
Rmodel[[varName]][!Rmodel$isData(varName)] <- inits[[varName]][!Rmodel$isData(varName)]
}
}
}
return(Rmodel)
}
getBUGSexampleDir <- function(example){
dir <- normalizePath(system.file("classic-bugs", package = "nimble"), winslash = "\\", mustWork=FALSE)
vol <- NULL
if(file.exists(normalizePath(file.path(dir, "vol1", example), winslash = "\\", mustWork=FALSE))) vol <- "vol1"
if(file.exists(normalizePath(file.path(dir, "vol2", example), winslash = "\\", mustWork=FALSE))) vol <- "vol2"
if(is.null(vol)) stop("Can't find path to ", example, ".\n")
dir <- normalizePath(file.path(dir, vol, example), winslash = "\\", mustWork=FALSE)
return(dir)
} |
"random.walk" <-
function(n, p = 0.5)
{
cumsum(rbern(n, p) * 2. - 1.)
} |
text <- "This is the website for “R for Data Science”. This book will teach you
how to do data science with R: You’ll learn how to get your data into R, get
it into the most useful structure, transform it, visualise it and model it."
test_text_df <- as.data.frame(x = text)
test_bigram_df <- saotd::bigram(DataFrame = test_text_df)
incorrect_bigram_df <- tibble::tribble(
~word, ~word2, ~n,
"data", "science", as.integer(2),
"structure", "transform", as.integer(1),
"youll", "learn", as.integer(1)
)
p <- saotd::bigram_network(BiGramDataFrame = test_bigram_df,
number = 1)
testthat::test_that("The bigram_network function is working as properly", {
testthat::expect_error(
object = saotd::bigram_network(
BiGramDataFrame = text),
"The input for this function is a Bigram data frame.")
testthat::expect_error(
object = saotd::bigram_network(
BiGramDataFrame = test_bigram_df,
number = 0),
"You must choose number of Bi-Grams greater than 1.")
testthat::expect_error(
object = saotd::bigram_network(
BiGramDataFrame = incorrect_bigram_df),
'The data frame is not properly constructed.
The data frame must have three columns: word1, word2 and n.')
})
testthat::test_that("The bigram_network plot retunrs ggplot object", {
testthat::expect_type(object = p,
type = "list")
}) |
source("get_geodata.R")
library(swissdd)
library(dplyr)
library(ggplot2)
library(sf)
library(tibble)
library(purrr)
library(transformr)
library(tweenr)
library(tidyr)
library(magick)
gd <- get_geodata() %>%
mutate(id = as.numeric(mun_id)) %>%
arrange(id) %>%
select(-id)
vd <- get_nationalvotes() %>%
mutate(id2 = as.numeric(mun_id)) %>%
arrange(id2) %>%
select(-id2) %>%
filter(id == 6360)
start <- gd %>%
filter(mun_id %in% vd$mun_id) %>%
rename(id = mun_id)
start %>%
ggplot() +
geom_sf()
radii <- vd %>%
filter(mun_id %in% start$id) %>%
select(mun_id, gueltigeStimmen) %>%
mutate(radius = sqrt(3000*gueltigeStimmen / pi)) %>%
arrange(as.numeric(mun_id)) %>%
pull(radius)
yes_share <- vd %>%
filter(mun_id %in% start$id) %>%
select(mun_id, jaStimmenInProzent) %>%
arrange(as.numeric(mun_id))
ids <- yes_share$mun_id
draw_circle <- function(id, centre_x = 0, centre_y = 0, radius = 1000, detail = 360, st = TRUE) {
i <- seq(0, 2 * pi, length.out = detail + 1)[-detail - 1]
x <- centre_x + (radius * sin(i))
y <- centre_y + (radius * cos(i))
if (st) {
cir <- st_polygon(list(cbind(x, y)[c(seq_len(detail), 1), , drop = FALSE]))
d <- st_sf(data.frame(id = id, geom = st_sfc(cir)))
} else {
d <- tibble(id = id, x = x, y = y)
}
return(d)
}
centroids <- as_tibble(st_coordinates(st_centroid(start$geometry)))
end <- pmap_dfr(list(ids, centroids$X, centroids$Y, radii), draw_circle)
end %>%
ggplot() +
geom_sf()
td <- tween_sf(start, end, ease = "cubic-in-out", nframes = 40, id = id)
disperse_around_municipality <- function(data, mun_name, intensity = 40) {
centroids <- suppressWarnings(st_centroid(data))
distances <- as_tibble(st_distance(centroids))
names(distances) <- data$id
id <- vd$mun_id[vd$mun_name == mun_name]
distance <- distances[[id]] / 1000
centroidsXY <- centroids %>%
st_coordinates() %>%
as_tibble() %>%
mutate(id = end$id)
direction_x <- (centroidsXY$X - centroidsXY$X[centroidsXY$id == id]) / distance
direction_y <- (centroidsXY$Y - centroidsXY$Y[centroidsXY$id == id]) / distance
for (i in c(1:nrow(data))[-which(distance == 0)]) {
data$geometry[i] <- data$geometry[i] + c(
direction_x[i] * (intensity / distance[i]),
direction_y[i] * (intensity / distance[i])
)
}
return(data)
}
get_collisions <- function(data) {
collisions <- data %>%
st_intersects(sparse = F) %>%
as_tibble() %>%
mutate(id = ids)
names(collisions) <- c(ids, "id")
collisions <- collisions %>%
pivot_longer(cols = -id, names_to = "id2") %>%
filter(!id == id2) %>%
filter(value) %>%
select(id, id2)
return(collisions)
}
solve_collisions <- function(id1, id2, data, stabilize = 5000, stabilize_factor = 0.1) {
polygons <- bind_rows(data %>% filter(id == id1), data %>% filter(id == id2))
radii <- ceiling(sqrt(st_area(polygons) / pi))
centroids <- suppressWarnings(st_centroid(polygons))
centroidsXY <- st_coordinates(centroids)
distance <- max(st_distance(centroids))
disp_mag <- sum(radii) - distance
disp_dir_x <- (centroidsXY[2,1] - centroidsXY[1,1]) / distance
disp_dir_y <- (centroidsXY[2,2] - centroidsXY[1,2]) / distance
polygon1 <- polygons %>%
filter(id == id1) %>%
st_geometry()
polygon2 <- polygons %>%
filter(id == id2) %>%
st_geometry()
if (max(radii) >= stabilize) {
if (radii[1] >= stabilize & radii[2] >= stabilize) {
if (radii[1] >= radii[2]) {
polygon1_t <- polygon1 + c(-disp_dir_x * disp_mag * stabilize_factor, -disp_dir_y * (disp_mag * stabilize_factor))
polygon2_t <- polygon2 + c(disp_dir_x * disp_mag * (1 - stabilize_factor), disp_dir_y * disp_mag * (1 - stabilize_factor))
} else {
polygon1_t <- polygon1 + c(-disp_dir_x * disp_mag * (1 - stabilize_factor), -disp_dir_y * disp_mag * (1 - stabilize_factor))
polygon2_t <- polygon2 + c(disp_dir_x * disp_mag * stabilize_factor, disp_dir_y * disp_mag * stabilize_factor)
}
} else {
if (radii[1] >= stabilize) {
polygon1_t <- polygon1
polygon2_t <- polygon2 + c(disp_dir_x * disp_mag, disp_dir_y * disp_mag)
} else {
polygon1_t <- polygon1 + c(-disp_dir_x * disp_mag, -disp_dir_y * disp_mag / 2)
polygon2_t <- polygon2
}
}
} else {
polygon1_t <- polygon1 + c(-disp_dir_x * (disp_mag / 2), -disp_dir_y * (disp_mag / 2))
polygon2_t <- polygon2 + c(disp_dir_x * (disp_mag / 2), disp_dir_y * (disp_mag / 2))
}
output <- st_sf(data.frame(id = c(id1, id2), geom = st_sfc(c(polygon1_t, polygon2_t))))
return(output)
}
end1 <- end
if ("261" %in% end$id) end1 <- disperse_around_municipality(end1, "Zürich", 40)
if ("230" %in% end$id) end1 <- disperse_around_municipality(end1, "Winterthur", 10)
end1 %>% ggplot() + geom_sf()
end2 <- end1
num_overlaps <- nrow(get_collisions(end2)) / 2
counter <- 0
while (num_overlaps > 0) {
collisions <- get_collisions(end2)
num_overlaps <- nrow(collisions) / 2
cat("Improvement attempts:", counter, "|| Collisions found:", num_overlaps, "\n")
collisions <- collisions %>%
group_by(id2) %>%
slice(1) %>%
group_by(id) %>%
slice(1) %>%
mutate(joint_id = ifelse(id < id2, paste0(id, id2), paste0(id2, id))) %>%
group_by(joint_id) %>%
slice(1) %>%
ungroup()
solved <- map2_dfr(collisions$id, collisions$id2, solve_collisions, end2)
counter <- counter + 1
for (i in 1:nrow(solved)) st_geometry(end2)[end2$id == solved[["id"]][i]] = solved[["geometry"]][i]
}
end2 %>% ggplot() + geom_sf()
td2 <- tween_sf(td, end2, ease = "cubic-in-out", nframes = 20, id = id) %>%
keep_state(nframes = 40)
td2 <- left_join(td2, yes_share, by = c("id" = "mun_id"))
plot_data <- function(data, pos, xlim, ylim) {
data <- data %>%
mutate(
stimmen = factor(case_when(
jaStimmenInProzent < 35 ~ "",
jaStimmenInProzent >= 35 & jaStimmenInProzent < 40 ~ "35",
jaStimmenInProzent >= 40 & jaStimmenInProzent < 45 ~ "40",
jaStimmenInProzent >= 45 & jaStimmenInProzent < 50 ~ "45",
jaStimmenInProzent >= 50 & jaStimmenInProzent < 55 ~ "50",
jaStimmenInProzent >= 55 & jaStimmenInProzent < 60 ~ "55",
jaStimmenInProzent >= 60 & jaStimmenInProzent < 65 ~ "60",
jaStimmenInProzent >= 65 ~ "65"
), levels = c("", "35", "40", "45", "50", "55", "60", "65")
)
)
p <- ggplot(data$geometry) +
geom_sf(aes(fill = data$stimmen), color = NA) +
coord_sf(xlim = xlim, ylim = ylim) +
scale_fill_manual(
values = c(
"
"
)
) +
theme_void() +
theme(legend.position = "none")
if (!pos %% 10 == 0) cat(".")
if (pos %% 10 == 0) cat(pos, "frames\n")
print(p)
}
xlim <- c(0.99 * min(st_coordinates(end2$geometry)[,1]), 1.01 * max(st_coordinates(end2$geometry)[,1]))
ylim <- c(0.99 * min(st_coordinates(end2$geometry)[,2]), 1.01 * max(st_coordinates(end2$geometry)[,2]))
img <- image_graph(res = 96)
datalist <- split(td2, td2$.frame)
out <- map2(datalist, 1:length(datalist), plot_data, xlim, ylim)
dev.off()
animation <- image_animate(img, fps = 20)
image_write(animation, "animation2.gif")
plot_data2 <- function(data, xlim, ylim) {
data %>%
mutate(
stimmen = factor(case_when(
jaStimmenInProzent < 35 ~ "",
jaStimmenInProzent >= 35 & jaStimmenInProzent < 40 ~ "35",
jaStimmenInProzent >= 40 & jaStimmenInProzent < 45 ~ "40",
jaStimmenInProzent >= 45 & jaStimmenInProzent < 50 ~ "45",
jaStimmenInProzent >= 50 & jaStimmenInProzent < 55 ~ "50",
jaStimmenInProzent >= 55 & jaStimmenInProzent < 60 ~ "55",
jaStimmenInProzent >= 60 & jaStimmenInProzent < 65 ~ "60",
jaStimmenInProzent >= 65 ~ "65"
), levels = c("", "35", "40", "45", "50", "55", "60", "65")
)
) %>%
ggplot() +
geom_sf(aes(fill = stimmen), color = NA) +
coord_sf(xlim = xlim, ylim = ylim) +
scale_fill_manual(
values = c(
"
"
),
drop = F,
name = "Percentage of yes votes",
guide = guide_legend(
direction = "horizontal",
keyheight = unit(2, units = "mm"),
keywidth = unit(c(25, rep(7, 6), 25), units = "mm"),
title.position = "top",
title.hjust = 0.5,
label.hjust = 1,
nrow = 1,
byrow = T,
reverse = T,
label.position = "bottom",
)
) +
theme_void() +
theme(legend.position = "bottom")
}
start %>%
left_join(yes_share, by = c("id" = "mun_id")) %>%
plot_data2(xlim, ylim)
ggsave("start.png", dpi = 500)
end %>%
left_join(yes_share, by = c("id" = "mun_id")) %>%
plot_data2(xlim, ylim)
ggsave("end1.png", dpi = 500)
end2 %>%
left_join(yes_share, by = c("id" = "mun_id")) %>%
plot_data2(xlim, ylim)
ggsave("end2.png", dpi = 500) |
context("Test numberimported and logical")
test_that("Logical equivalence", {
x <- TRUE
expect_that(x, equals(TRUE))
})
test_that("Numerical equivalence", {
x <- 1
expect_that(x, equals(1))
}) |
library(HRW) ; data(BostonMortgages) ; library(mgcv)
BostonMortgages$denyBinary <- as.numeric(BostonMortgages$deny == "yes")
fitInt <- gam(denyBinary ~ black + s(dir,by = factor(self),k = 27)
+ s(lvr,by = factor(self),k = 27)
+ pbcr + self + single + s(ccs,k = 4),
family = binomial, data = BostonMortgages)
ng <- 1001
dirLow <- 0 ; dirUpp <- 1
dirg <- seq(dirLow,dirUpp,length = ng)
lvrLow <- 0 ; lvrUpp <- 1
lvrg <- seq(lvrLow,lvrUpp,length = ng)
dirAveg <- rep(mean(BostonMortgages$dir),ng)
lvrAveg <- rep(mean(BostonMortgages$lvr),ng)
selfNog <- as.factor(rep("no",ng))
selfYesg <- as.factor(rep("yes",ng))
blackYesg <- as.factor(rep("yes",ng))
singleYesg <- as.factor(rep("yes",ng))
pbcrYesg <- as.factor(rep("yes",ng))
ccsAveg <- rep(mean(BostonMortgages$ccs),ng)
nonSelfCol <- "indianred3"
selfCol <- "darkgreen"
par(mfrow = c(1,2),mai = c(1.02,0.9,0.3,0.2)) ; cex.labVal <- 1.4
fdirNog <- predict(fitInt,type = "response",
newdata = data.frame(self = selfNog,dir = dirg,
lvr = lvrAveg,pbcr = pbcrYesg,black = blackYesg,
single = singleYesg,ccs = ccsAveg),se = TRUE)
fdirYesg <- predict(fitInt,type = "response",
newdata = data.frame(self = selfYesg,dir = dirg,
lvr = lvrAveg,pbcr = pbcrYesg,black = blackYesg,
single = singleYesg,ccs = ccsAveg),se = TRUE)
probdirNog <- fdirNog$fit
sdprobNog <- fdirNog$se.fit
lowprobdirNog <- probdirNog - 2*sdprobNog
uppprobdirNog <- probdirNog + 2*sdprobNog
lowprobdirNog[lowprobdirNog<0] <- 0
uppprobdirNog[uppprobdirNog>1] <- 1
probdirYesg <- fdirYesg$fit
sdprobYesg <- fdirYesg$se.fit
lowprobdirYesg <- probdirYesg - 2*sdprobYesg
uppprobdirYesg <- probdirYesg + 2*sdprobYesg
lowprobdirYesg[lowprobdirYesg<0] <- 0
uppprobdirYesg[uppprobdirYesg>1] <- 1
plot(0,type = "n",bty = "l",xlim = range(dirg),ylim = c(0,1),
xlab = "debt to income ratio",ylab = "probability of mortgage application denied",
cex.lab = cex.labVal)
rug(BostonMortgages$dir,col = "dodgerblue",quiet = TRUE)
lines(dirg,probdirNog,col = nonSelfCol,lwd = 2)
lines(dirg,lowprobdirNog,col = nonSelfCol,lwd = 2,lty = 2)
lines(dirg,uppprobdirNog,col = nonSelfCol,lwd = 2,lty = 2)
lines(dirg,probdirYesg,col = selfCol,lwd = 2)
lines(dirg,lowprobdirYesg,col = selfCol,lwd = 2,lty = 2)
lines(dirg,uppprobdirYesg,col = selfCol,lwd = 2,lty = 2)
abline(h = 0,col = "slateblue",lty = 2)
abline(h = 1,col = "slateblue",lty = 2)
legend(0.42,0.25,legend = c("self employed","not self-employed"),
lty = rep(1,2),lwd = rep(2,2),col = c(selfCol,nonSelfCol),cex = 0.8)
flvrNog <- predict(fitInt,type = "response",
newdata = data.frame(self = selfNog,dir = dirAveg,
lvr = lvrg,pbcr = pbcrYesg,black = blackYesg,
single = singleYesg,ccs = ccsAveg),se = TRUE)
flvrYesg <- predict(fitInt,type = "response",
newdata = data.frame(self = selfYesg,dir = dirAveg,
lvr = lvrg,pbcr = pbcrYesg,black = blackYesg,
single = singleYesg,ccs = ccsAveg),se = TRUE)
problvrNog <- flvrNog$fit
sdprobNog <- flvrNog$se.fit
lowproblvrNog <- problvrNog - 2*sdprobNog
uppproblvrNog <- problvrNog + 2*sdprobNog
lowproblvrNog[lowproblvrNog<0] <- 0
uppproblvrNog[uppproblvrNog>1] <- 1
problvrYesg <- flvrYesg$fit
sdprobYesg <- flvrYesg$se.fit
lowproblvrYesg <- problvrYesg - 2*sdprobYesg
uppproblvrYesg <- problvrYesg + 2*sdprobYesg
lowproblvrYesg[lowproblvrYesg<0] <- 0
uppproblvrYesg[uppproblvrYesg>1] <- 1
plot(0,type = "n",bty = "l",xlim = range(lvrg),ylim = c(0,1),
xlab = "loan size to property value ratio",
ylab = "probability of mortgage application denied",
cex.lab = cex.labVal)
rug(BostonMortgages$lvr,col = "dodgerblue",quiet = TRUE)
lines(lvrg,problvrNog,col = nonSelfCol,lwd = 2)
lines(lvrg,lowproblvrNog,col = nonSelfCol,lwd = 2,lty = 2)
lines(lvrg,uppproblvrNog,col = nonSelfCol,lwd = 2,lty = 2)
lines(lvrg,problvrYesg,col = selfCol,lwd = 2)
lines(lvrg,lowproblvrYesg,col = selfCol,lwd = 2,lty = 2)
lines(lvrg,uppproblvrYesg,col = selfCol,lwd = 2,lty = 2)
abline(h = 0,col = "slateblue",lty = 2)
abline(h = 1,col = "slateblue",lty = 2) |
allfaces <- function(hrep) {
stopifnot(is.character(hrep) || is.numeric(hrep))
validcdd(hrep, representation = "H")
if (is.character(hrep)) {
.Call(C_allfaces, hrep)
} else {
storage.mode(hrep) <- "double"
.Call(C_allfaces_f, hrep)
}
} |
test_no_context <- function() {
.Call(ptr_test_return, pairlist(NULL))
}
test_return <- function(node) {
call_with_cleanup(ptr_test_return, node)
}
test_jump <- function(node) {
call_with_cleanup(ptr_test_jump, node)
}
test_jumpy_cb <- function(node) {
call_with_cleanup(ptr_test_jumpy_cb, node)
}
test_no_cb <- function() {
call_with_cleanup(ptr_test_no_cb)
}
test_early_ok <- function(node) {
call_with_cleanup(ptr_test_early_ok, node)
}
test_early_jump <- function(node) {
call_with_cleanup(ptr_test_early_jump, node)
}
test_mixed <- function(node) {
call_with_cleanup(ptr_test_mixed, node)
} |
cli::test_that_cli("ui_todo() works", {
expect_snapshot(ui_todo("This is a todo."))
})
cli::test_that_cli("ui_info() works on Linux, Mac, and Solaris", {
skip_on_os("windows")
expect_snapshot(ui_info("This is an information."))
})
cli::test_that_cli("ui_done() works", {
expect_snapshot(ui_done("This is a task that was executed."))
})
cli::test_that_cli("ui_nope() works", {
expect_snapshot(ui_nope("This is something important that you must read."))
})
cli::test_that_cli("ui_ask() works", {
expect_snapshot(ui_ask("This is a question."))
})
cli::test_that_cli("ui_input() messages works", {
skip_if(interactive())
expect_snapshot(ui_input("Some input can be typed."))
})
cli::test_that_cli("ui_menu() messages works", {
skip_if(interactive())
expect_snapshot(ui_menu("Some choice can be typed"))
})
cli::test_that_cli("ui_warn() works", {
expect_snapshot(
ui_warn(
"this is a warning.",
ui_todo("this is a {.fn ui_*} call that follows the warning.")
)
)
})
cli::test_that_cli("ui_stop() works", {
expect_snapshot(
ui_stop(
"this is an error.",
ui_todo("this is a {.fn ui_*} call that follows the error.")
),
error = TRUE
)
})
cli::test_that_cli("ui_theme() works", {
expect_snapshot(ui_theme())
})
test_that("ui_input() returns an empty string in non-interactive mode", {
skip_if(interactive())
expect_identical(ui_input(), "")
})
test_that("ui_input() returns user's input in interactive mode", {
skip_on_ci()
skip_on_covr()
skip_on_cran()
skip_if(is_parallel())
cat("\n")
expect_identical(ui_input("What is the name of this package?"), "dotprofile")
})
test_that("ui_menu() validates argument answers", {
expect_error(ui_menu(answers = list()))
expect_snapshot_error(ui_menu(answers = NULL))
})
test_that("ui_menu() returns NA of a matching type in non-interactive mode", {
skip_if(interactive())
expect_identical(ui_menu(answers = "1"), NA_character_)
expect_identical(ui_menu(answers = 1+1i), NA_complex_)
expect_identical(ui_menu(answers = 1.0), NA_real_)
expect_identical(ui_menu(answers = 1L), NA_integer_)
expect_identical(ui_menu(answers = TRUE), NA)
})
test_that("ui_menu() returns user's choice in interactive mode", {
skip_on_ci()
skip_on_covr()
skip_on_cran()
skip_if(is_parallel())
cat("\n")
expect_identical(ui_menu("Choose between yes or no."), "yes")
}) |
plotSymDevFun <- function(CPF, n.grid = 100){
flim1 <- range(CPF$x)
flim2 <- range(CPF$y)
SymDevGraph = matrix(0,n.grid, n.grid)
for(i in 1:dim(CPF$fun1sims)[1]){
SymDevGraph = SymDevGraph +
SymDiffRaw(nondominated_points(cbind(rbind(CPF$fun1sims[i,],
CPF$fun2sims[i,]),
t(CPF$PF))),
nondominated_points(t(CPF$VE)),c(flim1[1],flim1[2]),
c(flim2[1],flim2[2]),n.grid)
}
filled.contour(seq(flim1[1], flim1[2],,n.grid), seq(flim2[1], flim2[2],,n.grid),
matrix(SymDevGraph/dim(CPF$fun1sims)[1],n.grid,n.grid),
col = gray(11:0/11), levels=seq(0,1,,11),
main ="Symmetric deviation function",
xlab=expression(f[1]),ylab=expression(f[2]),
plot.axes={axis(1);axis(2);
points(CPF$responses[,1], CPF$responses[,2], pch = 17,
col = "red")
plotParetoEmp(CPF$VE, col="blue", lwd=2)
plotParetoEmp(CPF$PF, col="red", lwd=2);
}
)
}
SymDiffRaw <- function(set1,set2, xlim, ylim, resGrid){
grille <- as.matrix(expand.grid(seq(xlim[1],xlim[2],,resGrid),seq(ylim[1],ylim[2],,resGrid)))
matRes <- rep(0,resGrid*resGrid)
for (i in 1:dim(grille)[1]){
a = is_dominated(cbind(grille[i,], set1))[1]
b = is_dominated(cbind(grille[i,], set2))[1]
if(a != b)
matRes[i] = 1
}
return(matRes)
} |
source("ESEUR_config.r")
maint=read.csv(paste0(ESEUR_dir, "maintenance/10.1.1.37.38.csv.xz"), as.is=TRUE)
maint$TASK.ID=NULL
maint$UNEXPEC=as.factor(maint$UNEXPEC)
maint$CONFIDENCE=as.factor(maint$CONFIDENCE)
pairs(~LOC+MEXPTOT+MEXPAPP, col=point_col,
cex.labels=1.3, cex.axis=1.2,
data=maint)
unexpect_mod=glm(UNEXPEC ~ ., data=maint, family="binomial")
summary(unexpect_mod)
unexpect_mod=glm(UNEXPEC ~ LOC, data=maint, family="binomial")
summary(unexpect_mod)
unexpect_mod=glm(CONFIDENCE ~ .-UNEXPEC, data=maint, family="binomial")
summary(unexpect_mod) |
append_geoid <- function(address, geoid_type = 'bl') {
if ("lat" %in% colnames(address) && "lon" %in% colnames(address)) {
geoids <- vector(mode="character", length = nrow(address))
for (i in 1:nrow(address)) {
geoids[i] <- call_geolocator_latlon(address$lat[i], address$lon[i])
}
} else {
geoids <- vector(mode="character", length = nrow(address))
for (i in 1:nrow(address)) {
geoids[i] <- call_geolocator(
as.character(address$street[i]),
as.character(address$city[i]),
as.character(address$state[i])
)
}
}
address <- dplyr::mutate(address, geoid = geoids)
if (geoid_type == 'co') {
end <- 5
} else if (geoid_type == 'tr') {
end <- 11
} else if (geoid_type == 'bg') {
end <- 12
} else {
end <- 15
}
address <- dplyr::mutate(address,
geoid = ifelse(is.na(geoid), NA_character_, substr(geoid, 1, end)))
return(address)
}
call_geolocator <- function(street, city, state) {
call_start <- "https://geocoding.geo.census.gov/geocoder/geographies/address?"
url <- paste0(
"street=", utils::URLencode(street),
"&city=", utils::URLencode(city),
"&state=", state
)
call_end <- "&benchmark=Public_AR_Census2010&vintage=Census2010_Census2010&layers=14&format=json"
url_full <- paste0(call_start, url, call_end)
r <- httr::GET(url_full)
httr::stop_for_status(r)
response <- httr::content(r)
if (length(response$result$addressMatches) == 0) {
message(paste0("Address (",
street, " ", city, " ", state,
") returned no address matches. An NA was returned."))
return(NA_character_)
} else {
if (length(response$result$addressMatches) > 1) {
message(paste0("Address (",
street, " ", city, " ", state,
") returned more than one address match. The first match was returned."))
}
return(response$result$addressMatches[[1]]$geographies$`Census Blocks`[[1]]$GEOID)
}
}
call_geolocator_latlon <- function(lat, lon) {
call_start <- "https://geocoding.geo.census.gov/geocoder/geographies/coordinates?"
url <- paste0(
"x=", lon,
"&y=", lat
)
call_end <- "&benchmark=Public_AR_Census2010&vintage=Census2010_Census2010&layers=14&format=json"
url_full <- paste0(call_start, url, call_end)
r <- httr::GET(url_full)
httr::stop_for_status(r)
response <- httr::content(r)
if (length(response$result$geographies$`Census Blocks`) == 0) {
message(paste0("Lat/lon (", lat, ", ", lon,
") returned no geocodes. An NA was returned."))
return(NA_character_)
} else {
if (length(response$result$geographies$`Census Blocks`) > 1) {
message(paste0("Lat/lon (", lat, ", ", lon,
") returned more than geocode. The first match was returned."))
}
return(response$result$geographies$`Census Blocks`[[1]]$GEOID)
}
} |
NNS.dep = function(x,
y = NULL,
asym = FALSE,
p.value = FALSE,
print.map = FALSE){
if(any(class(x)==c("tbl", "data.table"))) x <- as.vector(unlist(x))
if(sum(is.na(x)) > 0) stop("You have some missing values, please address.")
if(p.value){
y_p <- replicate(100, sample.int(length(y)))
x <- cbind(x, y, matrix(y[y_p], ncol = dim(y_p)[2], byrow = F))
y <- NULL
}
if(!is.null(y)){
x <- as.numeric(x)
l <- length(x)
y <- as.numeric(y)
obs <- max(10, l/5)
if(print.map) PART <- NNS.part(x, y, order = NULL, obs.req = obs, min.obs.stop = TRUE, type = "XONLY", Voronoi = TRUE) else PART <- NNS.part(x, y, order = NULL, obs.req = obs, min.obs.stop = TRUE, type = "XONLY", Voronoi = FALSE)
if(dim(PART$regression.points)[1]==0) return(list("Correlation" = 0, "Dependence" = 0))
PART <- PART$dt
PART <- PART[complete.cases(PART),]
PART[, weights := .N/l, by = prior.quadrant]
weights <- PART[, weights[1], by = prior.quadrant]$V1
ll <- expression(max(min(100, .N), 8))
res <- suppressWarnings(tryCatch(PART[, sign(cor(x[1:eval(ll)],y[1:eval(ll)]))*summary(lm(y[1:eval(ll)]~poly(x[1:eval(ll)], max(1, min(10, as.integer(sqrt(.N))-1)), raw = TRUE)))$r.squared, by = prior.quadrant],
error = function(e) PART[, NNS.copula(cbind(x,y)), by = prior.quadrant]))
if(sum(is.na(res))>0) res[is.na(res)] <- NNS.copula(cbind(x,y))
res_xy <- suppressWarnings(tryCatch(PART[, sign(cor(x[1:eval(ll)],(y[1:eval(ll)])))*summary(lm(abs(y[1:eval(ll)])~poly(x[1:eval(ll)], max(1, min(10, as.integer(sqrt(.N))-1)), raw = TRUE)))$r.squared, by = prior.quadrant],
error = function(e) PART[, NNS.copula(cbind(x,y)), by = prior.quadrant]))
res_yx <- suppressWarnings(tryCatch(PART[, sign(cor(y[1:eval(ll)],(x[1:eval(ll)])))*summary(lm(abs(x[1:eval(ll)])~poly(y[1:eval(ll)], max(1, min(10, as.integer(sqrt(.N))-1)), raw = TRUE)))$r.squared, by = prior.quadrant],
error = function(e) PART[, NNS.copula(cbind(x,y)), by = prior.quadrant]))
if(sum(is.na(res_xy))>0) res_xy[is.na(res_xy)] <- NNS.copula(cbind(x,y))
if(sum(is.na(res_yx))>0) res_yx[is.na(res_yx)] <- NNS.copula(cbind(x,y))
if(asym) dependence <- sum(abs(res_xy$V1) * weights) else dependence <- max(sum(abs(res$V1) * weights),
sum(abs(res_xy$V1) * weights),
sum(abs(res_yx$V1) * weights))
lx <- PART[, length(unique(x))]
ly <- PART[, length(unique(y))]
degree_x <- min(10, max(1,lx-1), max(1,ly-1))
I_x <- lx > sqrt(l)
I_y <- ly > sqrt(l)
I <- I_x * I_y
poly_base <- dependence
if(I == 1) poly_base <- suppressWarnings(tryCatch(summary(lm(abs(y)~poly(x, degree_x), raw = TRUE))$r.squared,
warning = function(w) dependence,
error = function(e) dependence))
dependence <- mean(c(rep(dependence,3), poly_base))
corr <- mean(c(sum(res$V1 * weights),
sum(res_xy$V1 * weights),
sum(res_yx$V1 * weights)))
return(list("Correlation" = corr,
"Dependence" = dependence))
} else {
if(p.value){
original.par <- par(no.readonly = TRUE)
nns.mc <- apply(x, 2, function(g) NNS.dep(x[,1], g))
cors <- unlist(lapply(nns.mc, "[[", 1))
deps <- unlist(lapply(nns.mc, "[[", 2))
cor_lower_CI <- LPM.VaR(.025, 0, cors[-c(1,2)])
cor_upper_CI <- UPM.VaR(.025, 0, cors[-c(1,2)])
dep_lower_CI <- LPM.VaR(.025, 0, deps[-c(1,2)])
dep_upper_CI <- UPM.VaR(.025, 0, deps[-c(1,2)])
if(print.map){
par(mfrow = c(1, 2))
hist(cors[-c(1,2)], main = "NNS Correlation", xlab = NULL, xlim = c(min(cors), max(cors[-1])))
abline(v = cors[2], col = "red", lwd = 2)
mtext("Result", side = 3, col = "red", at = cors[2])
abline(v = cor_lower_CI, col = "red", lwd = 2, lty = 3)
abline(v = cor_upper_CI , col = "red", lwd = 2, lty = 3)
hist(deps[-c(1,2)], main = "NNS Dependence", xlab = NULL, xlim = c(min(deps), max(deps[-1])))
abline(v = deps[2], col = "red", lwd = 2)
mtext("Result", side = 3, col = "red", at = deps[2])
abline(v = dep_lower_CI , col = "red", lwd = 2, lty = 3)
abline(v = dep_upper_CI , col = "red", lwd = 2, lty = 3)
par(mfrow = original.par)
}
return(list("Correlation" = as.numeric((cors)[2]),
"Correlation p.value" = min(LPM(0, cors[2], cors[-c(1,2)]),
UPM(0, cors[2], cors[-c(1,2)])),
"Correlation 95% CIs" = c(cor_lower_CI, cor_upper_CI),
"Dependence" = as.numeric((deps)[2]),
"Dependence p.value" = min(LPM(0, deps[2], deps[-c(1,2)]),
UPM(0, deps[2], deps[-c(1,2)])),
"Dependence 95% CIs" = c(dep_lower_CI, dep_upper_CI)))
} else return(NNS.dep.matrix(x, asym = asym))
}
} |
test_that("testing the cuts points", {
expect_error(alphabet_to_cuts(0))
expect_error(alphabet_to_cuts(33))
expect_equal(length(alphabet_to_cuts(3)), 3)
expect_equal(alphabet_to_cuts(4)[3], 0)
for (i in c(2:20)) {
cuts <- alphabet_to_cuts(i)
expect_equal(cuts[1], -Inf)
expect_equal(length(cuts), i)
expect_true(cuts[length(cuts)] < 2.0)
}
}) |
CNOT5_34 <- function(a){
cnot5_34=TensorProd(diag(2), CNOT4_23(diag(16)))
result = cnot5_34 %*% a
result
} |
PKshow <- function(nonmemObj=NULL, table.Rowv=FALSE, table.Colv=FALSE)
{
PKoutput(nonmemObj, table.Rowv, table.Colv)
PKcode()
file.location <- paste("file://", getwd(),"/PKindex.html", sep="")
browseURL(file.location, browser = getOption("browser"))
} |
ts_default <- function(x) {
if (inherits(x, "ts")) return(x)
z <- ts_dts(x)
cname <- dts_cname(z)
if (identical(cname$time, "time") && identical(cname$value, "value")) {
return(x)
}
setnames(z, cname$time, "time")
setnames(z, cname$value, "value")
cname$time <- "time"
cname$value <- "value"
setcolorder(z, c(setdiff(names(z), c("time", "value")), c("time", "value")))
setattr(z, "cname", cname)
copy_class(z, x)
} |
plot_gamma = function(result, title = "") {
gamma = result$gamma
nniter = nrow(gamma)
colors <- c("lightblue", "darkblue")
datgamma = as.data.frame(gamma[1:nniter, ])
T = ncol(gamma)
colnames(datgamma) = paste0("v", 1:T)
rownames(datgamma) = paste0("iter", 1:nniter)
datgamma$id = rownames(datgamma)
datgamma$id = factor(datgamma$id, levels = datgamma$id)
colnames(datgamma) = factor(colnames(datgamma), levels = colnames(datgamma))
mdatgamma = reshape2::melt(datgamma, id = "id")
colnames(mdatgamma)[3] = "gamma"
mdatgamma$gamma = as.factor(mdatgamma$gamma)
g = ggplot2::ggplot(mdatgamma, aes(x = .data$variable, y = .data$id, fill = .data$gamma)) + geom_tile(color = "white") +
scale_fill_discrete() + ylab("iterations") + xlab("gamma") + ggtitle(title)
return(g)
}
plot_beta = function(result, title = "") {
beta = result$beta
T = ncol(beta)
nniter = nrow(beta)
datbeta = as.data.frame(beta[1:nniter, ])
colnames(datbeta) = paste0("v", 1:T)
rownames(datbeta) = paste0("iter", 1:nniter)
datbeta$id = rownames(datbeta)
datbeta$id = factor(datbeta$id, levels = datbeta$id)
datbeta2 = reshape::melt(datbeta, id = "id")
datbeta2$xx = rep(1:nniter, T)
g = ggplot2::ggplot(datbeta2, aes(x = .data$xx, y = .data$value, col = .data$variable)) + ggplot2::geom_line(alpha = 0.7) +
ggplot2::ylab("beta") + ggplot2::xlab("iteration") + ggplot2::ggtitle(title)
plot(g)
return(g)
}
beta_dist = function(result, title = "") {
beta = result$beta[-1, ]
T = ncol(beta)
nniter = nrow(beta)
datbeta = as.data.frame(beta[1:nniter, ])
colnames(datbeta) = paste0("v", 1:T)
rownames(datbeta) = paste0("iter", 1:nniter)
datbeta$id = rownames(datbeta)
datbeta$id = factor(datbeta$id, levels = datbeta$id)
datbeta2 = reshape::melt(datbeta, id = "id")
datbeta2$xx = rep(1:nniter, T)
g = ggplot2::ggplot(datbeta2, aes(x = .data$variable, y = .data$value)) + ggplot2::geom_violin()
return(g)
}
plot_sigma = function(result, title = "") {
Sigma = apply(result$Sigma, c(1, 2), mean)
T = nrow(Sigma)
Sigma = as.data.frame(Sigma)
colnames(Sigma) = paste0("v", 1:T)
Sigma$id = paste0("v", 1:T)
msig = reshape2::melt(Sigma, id = "id")
msig$id = factor(msig$id, levels = paste0("v", 1:10))
msig$variable = factor(msig$variable, levels = paste0("v", 1:10))
g = ggplot2::ggplot(msig, aes(x = .data$id, y = .data$variable, fill = .data$value)) + ggplot2::geom_tile() +
ggplot2::scale_fill_gradient(limits = c(0, 1.2)) + ggplot2::ylab("") + ggplot2::xlab("") +
ggplot2::geom_text(aes(label = round(.data$value, 2)))
plot(g)
return(g)
} |
isNegativeNumberVectorOrNull <- function(argument, default = NULL, stopIfNot = FALSE, n = NA, message = NULL, argumentName = NULL) {
checkarg(argument, "N", default = default, stopIfNot = stopIfNot, nullAllowed = TRUE, n = NA, zeroAllowed = TRUE, negativeAllowed = TRUE, positiveAllowed = FALSE, nonIntegerAllowed = TRUE, naAllowed = FALSE, nanAllowed = FALSE, infAllowed = FALSE, message = message, argumentName = argumentName)
} |
yy <- function(a=4){
utils::head(stats::runif(10),a)
}
zz <- function(v=10,a=8){
utils::head(stats::runif(v),a)
}
yy(6)
zz(30,3) |
par.opt <- function(sens.results, ts, target.data, par.range) {
iteration <- dim(sens.results)[1]
res <- array(NA, dim=c(length(par.range), iteration, 2), dimnames=list(paste("par.val", par.range), paste("Iteration", seq(1:iteration), sep=" "), c("Residuals of mean", "Residuals of variance")))
for(p in 1:length(par.range)){
res[p,,1] <- abs(mean(target.data)-sens.results[, ts, "trait.pop.mean", p])
res[p,,2] <- abs(var(target.data)-sens.results[, ts, "trait.pop.variance", p])
}
boot_curr <- boot(target.data, statistic=sample.mean, R=100)
ci.curr <- boot.ci(boot_curr, conf=0.95, type="basic")
low <- ci.curr$basic[4]
high <- ci.curr$basic[5]
cont <- array(NA, dim=c(length(par.range), 2), dimnames=list(paste("par.val", par.range), c("Difference in means", "Proportion contained")))
for(p in 1:length(par.range)){
cont[,1] <- abs(mean(target.data)-apply(sens.results[, ts, "trait.pop.mean", ], 2, mean, na.rm=TRUE))
cont[,2] <- apply(sens.results[, ts, "trait.pop.mean", ], 2, function(x)sum(x > low & x < high, na.rm=TRUE))/iteration
}
list("Residuals"=res, "Target.match"=cont)
} |
x <- c("spam, spam, bacon, and spam", "eggs and spam")
E(substr(x, -4), c("spam", "spam"))
E(substr(x, -4, -4), c("s", "s"))
E(substr(x, -4, -5), c("", ""))
E(
`substr<-`(x, -4, -5, value="spammity "),
c("spam, spam, bacon, and spammity spam", "eggs and spammity spam")
)
E(substrl(x, -4, 4), c("spam", "spam"))
E(substrl(x, -4, c(-1, 0, 1, 3)), c(NA, "", "s", "spa"))
E(`substrl<-`(x, -4, 0, value="spammity "), c("spam, spam, bacon, and spammity spam", "eggs and spammity spam"))
E(`substrl<-`(x, -4, 2, value="j"), c("spam, spam, bacon, and jam", "eggs and jam"))
E(`substrl<-`(x, -4, -1, value="spammity "), x)
E(gsubstr(x, 1, 4), list("spam", "eggs"))
E(gsubstr(x, c(13, 1), c(17, 4)), list("bacon", "eggs"))
E(gsubstr(x, list(c(13, 1), 1), list(c(17, 4), 4)), list(c("bacon", "spam"), "eggs"))
E(`gsubstr<-`(x, -4, -1, value="buckwheat"), c("spam, spam, bacon, and buckwheat", "eggs and buckwheat"))
x <- c("aaa", "1aa2aaa3", "a", "bb", "\u0105\U0001F64Baaaaaaaa", NA)
p <- c("(?<x>a)(?<y>a)?(?<z>a)?", "a+")
E(substrl(x, regexpr2(x, p)), c("aaa", "aa", "a", NA, "aaa", NA))
E(`substrl<-`(x, regexpr2(x, p), value="!"), c("!", "1!2aaa3", "!", "bb", "\u0105\U0001F64B!aaaaa", NA))
E(gsubstrl(x, gregexpr2(x, p)), list("aaa", c("aa", "aaa"), "a", character(0), c("aaa", "aaa", "aa"), NA_character_))
E(`gsubstrl<-`(x, gregexpr2(x, p), value="!"), c("!", "1!2!3", "!", "bb", "\u0105\U0001F64B!!!", NA))
E(`gsubstrl<-`(x, gregexpr2(x, p), value=list(c("!", "?", "@"))), P(c("!", "1!2?3", "!", "bb", "\u0105\U0001F64B!?@", NA), warning=TRUE)) |
poppr.amova <- function(x, hier = NULL, clonecorrect = FALSE, within = TRUE,
dist = NULL, squared = TRUE, freq = TRUE,
correction = "quasieuclid", sep = "_", filter = FALSE,
threshold = 0, algorithm = "farthest_neighbor",
threads = 1L, missing = "loci", cutoff = 0.05,
quiet = FALSE, method = c("ade4", "pegas"), nperm = 0){
if (!inherits(x, c("genind", "genlight"))) stop(paste(substitute(x), "must be a genind object."))
if (is.null(hier)) stop("A population hierarchy must be specified")
methods <- c("ade4", "pegas")
method <- match.arg(method, methods)
setPop(x) <- hier
is_genind <- is.genind(x)
haploid <- all(ploidy(x) == 1)
within <- if (haploid) FALSE else within
heterozygous <- if (is_genind) check_Hs(x) else TRUE
codominant <- if (is_genind) x@type != "PA" else TRUE
freq <- freq & codominant & !haploid
if (!is.clone(x)) {
x <- if (is_genind) as.genclone(x) else as.snpclone(x)
}
if (filter && within && !haploid) {
msg <- paste("`filter = TRUE` overrides `within = TRUE`.\n",
"The calculations will run with the option `within = FALSE`.\n",
"To remove this warning, set either `filter` or `within` to `FALSE`.")
warning(msg)
within <- FALSE
}
if (filter && (haploid | !within | !heterozygous | !codominant)) {
if (!is(x@mlg, "MLG")) {
x@mlg <- new("MLG", x@mlg)
}
if (!quiet) {
message("Filtering ...")
message("Original multilocus genotypes ... ", nmll(x, "original"))
}
if (is.null(dist)) {
if (is_genind) {
dist <- dist(tab(x, freq = freq))
} else {
dist <- bitwise.dist(x, euclidean = TRUE, scale_missing = TRUE, threads = threads)
}
squared <- FALSE
}
filt_stats <- mlg.filter(x, threshold = threshold, algorithm = algorithm,
distance = dist, stats = "ALL", threads = threads)
dist <- as.dist(filt_stats$DISTANCE)
x@mlg@mlg["contracted"] <- filt_stats$MLGS
distname(x@mlg) <- "dist"
distalgo(x@mlg) <- algorithm
cutoff(x@mlg)["contracted"] <- threshold
mll(x) <- "contracted"
if (!quiet) message("Contracted multilocus genotypes ... ", nmll(x))
}
if (clonecorrect) {
x <- clonecorrect(x, strata = hier, keep = seq(all.vars(hier)))
}
if (is_genind) {
x <- missingno(x, type = missing, cutoff = cutoff, quiet = quiet)
} else {
if (!all(lengths(NA.posi(x)) == 0L)) warning("Missing data are not filtered from genlight data.")
}
full_ploidy <- if (is_genind) codominant && sum(tabulate(get_local_ploidy(x)) > 0) == 1 else TRUE
if (within && heterozygous && codominant && !haploid && full_ploidy) {
hier <- update(hier, ~./Individual)
x <- make_haplotypes(x)
x <- if (is_genind) as.genclone(x) else as.snpclone(x)
} else if (within && codominant && !full_ploidy && is.null(dist)) {
warning(paste("Data with mixed ploidy or ambiguous allele dosage cannot have",
"within-individual variance calculated until the dosage is correctly",
"estimated.\n\n",
"This function will return the summary statistic, rho (Ronfort et al 1998)",
"but be aware that this estimate will be skewed due to ambiguous dosage.",
if (test_zeroes(x)) "If you have zeroes encoded in your data, you may wish to remove them.\n",
"To remove this warning, use within = FALSE")
)
}
hierdf <- strata(x, formula = hier)
if (method == "ade4") xstruct <- make_ade_df(hier, hierdf)
if (is.null(dist)) {
squared <- FALSE
if (method == "ade4") {
if (is_genind) {
xdist <- dist(tab(clonecorrect(x, strata = NA), freq = freq))
} else {
xdist <- bitwise.dist(clonecorrect(x, strata = NA),
euclidean = TRUE, scale_missing = TRUE, threads = threads)
}
} else {
if (is_genind) {
xdist <- dist(tab(x, freq = freq))
} else {
xdist <- bitwise.dist(x, euclidean = TRUE, scale_missing = TRUE, threads = threads)
}
}
} else {
datalength <- choose(nInd(x), 2)
mlgs <- mlg(x, quiet = TRUE)
mlglength <- choose(mlgs, 2)
if (length(dist) > mlglength & length(dist) == datalength) {
corrected <- if (method == "ade4") .clonecorrector(x) else TRUE
xdist <- as.dist(as.matrix(dist)[corrected, corrected])
} else if (length(dist) == mlglength) {
xdist <- dist
} else {
distobs <- ceiling(sqrt(length(dist)*2))
msg <- paste("\nDistance matrix does not match the data.\n",
"\n\tUncorrected observations expected..........", nInd(x),
"\n\tClone corrected observations expected......", mlgs,
"\n\tObservations in provided distance matrix...", distobs,
ifelse(within == TRUE, "\n\n\tTry setting within = FALSE.", "\n"))
stop(msg)
}
if (squared) {
xdist <- sqrt(xdist)
}
}
if (!is.euclid(xdist)) {
CORRECTIONS <- c("cailliez", "quasieuclid", "lingoes")
try(correct <- match.arg(correction, CORRECTIONS), silent = TRUE)
if (!exists("correct")){
stop(not_euclid_msg(correction))
} else {
correct_fun <- match.fun(correct)
if (correct == CORRECTIONS[2]){
message("Distance matrix is non-euclidean.")
message(c("Using quasieuclid correction method.",
" See ?quasieuclid for details."))
xdist <- correct_fun(xdist)
} else {
xdist <- correct_fun(xdist, print = TRUE, cor.zero = FALSE)
}
}
}
if (method == "ade4") {
allmlgs <- unique(mlg.vector(x))
xtab <- t(mlg.table(x, plot = FALSE, quiet = TRUE, mlgsub = allmlgs))
xtab <- as.data.frame(xtab)
return(ade4::amova(samples = xtab, distances = xdist, structures = xstruct))
} else {
form <- paste(all.vars(hier), collapse = "/")
hier <- as.formula(paste("xdist ~", form))
return(pegas::amova(hier, data = hierdf, nperm = nperm, is.squared = FALSE))
}
} |
TIRTfit <- function(fit, data) {
version <- utils::packageVersion("thurstonianIRT")
structure(nlist(fit, data, version), class = "TIRTfit")
}
is.TIRTfit <- function(x) {
inherits(x, "TIRTfit")
}
print.TIRTfit <- function(x, ...) {
print(x$fit, ...)
}
summary.TIRTfit <- function(object, ...) {
summary(object$fit, ...)
}
predict.TIRTfit <- function(object, newdata = NULL, ...) {
if (inherits(object$fit, "stanfit")) {
out <- predict_stan(object, newdata = newdata, ...)
} else if (inherits(object$fit, "mplusObjectTIRT")) {
out <- predict_mplus(object, newdata = newdata, ...)
} else if (inherits(object$fit, "lavaan")) {
out <- predict_lavaan(object, newdata = newdata, ...)
}
out
}
gof.TIRTfit <- function(object, ...) {
if (!inherits(object$fit, "lavaan")) {
stop("gof.TIRTfit currently only works for lavaan fitted TIRT models.")
}
N <- length(unique(object$data$person))
chi_sq <- object$fit@test$scaled.shifted$stat
if (is.null(chi_sq)) {
chi_sq <- NA
}
df <- object$fit@test$scaled.shifted$df
if (is.null(df)) {
df <- NA
}
blocks <- unique(object$data$block)
redundancies <- rep(NA, length(blocks))
for (i in seq_along(blocks)) {
sel_items <- unique(object$data$itemC[object$data$block == blocks[i]])
n_items <- length(sel_items)
redundancies[i] <- n_items * (n_items - 1) * (n_items - 2) / 6
}
df <- df - sum(redundancies)
p_val <- 1 - stats::pchisq(chi_sq, df)
RMSEA <- ifelse(df > chi_sq, 0, sqrt((chi_sq - df)/(df * (N - 1))))
gof <- c(chi_sq = chi_sq, df = df, p_val = p_val, RMSEA = RMSEA)
gof
}
gof <- function(object, ...) {
UseMethod("gof")
} |
xvalDapc <- function (x, ...) UseMethod("xvalDapc")
.group_sampler <- function(e, grp, training.set){
group_e <- grp == e
N_group_e <- sum(group_e)
if (N_group_e < 2){
return(which(group_e))
} else {
samp_group <- which(group_e)
samp_size <- round(training.set * N_group_e)
return(sample(samp_group, size = samp_size))
}
}
.boot_group_sampler <- function(dat = list(DATA = NULL, GRP = NULL, PCA = NULL,
KEEP = NULL),
mle = NULL){
to_keep <- unlist(lapply(levels(dat$GRP), .group_sampler, dat$GRP, mle))
dat$PCA$li <- dat$PCA$li[to_keep, , drop = FALSE]
dat$KEEP <- to_keep
return(dat)
}
.boot_dapc_pred <- function(x, n.pca = n.pca, n.da = n.da, result = "overall"){
if (length(x$KEEP) == nrow(x$DATA)){
out <- 1
} else {
new_dat <- x$DATA[-x$KEEP, ,drop = FALSE]
train_dat <- x$DATA[x$KEEP, ,drop = FALSE]
new_grp <- x$GRP[-x$KEEP]
train_grp <- x$GRP[x$KEEP]
dapclist <- list(train_dat,
train_grp,
n.pca = n.pca,
n.da = n.da,
dudi = x$PCA)
temp.dapc <- suppressWarnings(do.call("dapc", dapclist))
temp.dapc <- suppressWarnings(dapc(train_dat, train_grp, dudi = x$PCA,
n.pca = n.pca, n.da = n.da))
temp.pred <- predict.dapc(temp.dapc, newdata = new_dat)
if (identical(result, "overall")){
out <- mean(temp.pred$assign == new_grp)
}
if (identical(result, "groupMean")){
out <- mean(tapply(temp.pred$assign == new_grp, new_grp, mean), na.rm = TRUE)
}
}
return(out)
}
.get.prop.pred <- function(n.pca, x, n.da, groups, grp, training.set,
pcaX, result = "overall", reps = 100,
...){
bootlist <- list(DATA = x, GRP = grp, PCA = pcaX, KEEP = 1:nrow(x))
out <- boot::boot(bootlist, .boot_dapc_pred, sim = "parametric", R = reps,
ran.gen = .boot_group_sampler, mle = training.set,
n.pca = n.pca, n.da = n.da, result = result, ...)$t
return(as.vector(out))
}
xvalDapc.default <- function(x, grp, n.pca.max = 300, n.da = NULL, training.set = 0.9,
result = c("groupMean", "overall"), center = TRUE, scale = FALSE,
n.pca = NULL, n.rep = 30, xval.plot = TRUE, ...){
grp <- factor(grp)
n.pca <- n.pca[n.pca > 0]
if(!is.null(n.da)){
n.da <- n.da
}else{
n.da <- length(levels(grp))-1}
if(missing(training.set)){
training.set <- 0.9
}else{
training.set <- training.set}
if(missing(n.rep)){
n.rep <- 30
}else{
n.rep <- n.rep}
if(missing(result)){
result <- "groupMean"
}else{
if(length(result) > 1) result <- result[1]
result <- result}
N <- nrow(x)
groups <- levels(grp)
group.n <- as.vector(table(grp))
popmin <- min(group.n)
if(popmin == 1){
singles <- which(group.n == 1)
counter <- length(singles)
if(counter == 1){
msg <- "1 group has only 1 member so it cannot be represented in both training and validation sets."
}else{
msg <- paste(counter, "groups have only 1 member: these groups cannot be represented in both training and validation sets.")
}
warning(msg)
popmin <- min(group.n[-which(group.n==1)])
}
training.set2 <- (popmin - 1)/popmin
if(training.set2 < training.set) training.set <- training.set2
N.training <- round(N*training.set)
if(missing(n.pca.max)) n.pca.max <- min(dim(x))
pcaX <- dudi.pca(x, nf=n.pca.max, scannf=FALSE, center=center, scale=scale)
n.pca.max <- min(n.pca.max, pcaX$rank, N.training-1)
if(n.pca.max < 10){
runs <- n.pca.max
}else{
runs <- 10}
if(is.null(n.pca)){
n.pca <- round(pretty(1:n.pca.max, runs))
}
n.pca <- n.pca[n.pca>0 & n.pca<(N.training-1) & n.pca<n.pca.max]
res.all <- unlist(lapply(n.pca, .get.prop.pred, x, n.da, groups, grp,
training.set, pcaX, result,
n.rep, ...))
xval <- data.frame(n.pca=rep(n.pca, each=n.rep), success=res.all)
n.pcaF <- as.factor(xval$n.pca)
successV <- as.vector(xval$success)
pca.success <- tapply(successV, n.pcaF, mean)
n.opt <- which.max(tapply(successV, n.pcaF, mean))
temp <- seq(from=1, to=length(xval$n.pca), by=n.rep)
orary <-c(temp+(n.rep-1))
index <-c(1:length(temp))
lins <-sapply(index, function(e) seq(from=temp[e], to=orary[e]))
lin <-c(1:ncol(lins))
col <-successV
cait<-sapply(lin, function(e) ((col[lins[,e]])-1)^2)
FTW <-sapply(lin, function(e) sum(cait[,e])/n.rep)
RMSE <- sqrt(FTW)
names(RMSE) <- xval$n.pca[temp]
best.n.pca <- names(which(RMSE == min(RMSE)))
if(length(best.n.pca) > 1) best.n.pca <- best.n.pca[length(best.n.pca)]
n.pca <- as.integer(best.n.pca)
n.da <- nlevels(grp)-1
dapc1 <- suppressWarnings(dapc(x, grp, n.pca=n.pca, n.da=n.da))
snps <- x
phen <- grp
random <- replicate(300, mean(tapply(sample(phen)==phen, phen, mean)))
q.phen <- quantile(random, c(0.025,0.5,0.975))
if(xval.plot==TRUE){
smoothScatter(xval$n.pca, successV, nrpoints=Inf, pch=20, col=transp("black"),
ylim=c(0,1), xlab="Number of PCA axes retained",
ylab="Proportion of successful outcome prediction",
main="DAPC Cross-Validation")
abline(h=q.phen, lty=c(2,1,2))
}
xvalResults <- list(xval, q.phen, pca.success, (names(n.opt)), RMSE, best.n.pca, dapc1)
names(xvalResults)[[1]] <- "Cross-Validation Results"
names(xvalResults)[[2]] <- "Median and Confidence Interval for Random Chance"
names(xvalResults)[[3]] <- "Mean Successful Assignment by Number of PCs of PCA"
names(xvalResults)[[4]] <- "Number of PCs Achieving Highest Mean Success"
names(xvalResults)[[5]] <- "Root Mean Squared Error by Number of PCs of PCA"
names(xvalResults)[[6]] <- "Number of PCs Achieving Lowest MSE"
names(xvalResults)[[7]] <- "DAPC"
return(xvalResults)
}
xvalDapc.data.frame <- xvalDapc.default
xvalDapc.matrix <- xvalDapc.data.frame
xvalDapc.genlight <- function(x, ...){
xvalDapc.matrix(as.matrix(x), ...)
}
xvalDapc.genind <- function(x, ...){
xvalDapc.matrix(tab(x), ...)
} |
distinctiveness_range = function(pres_matrix, dist_matrix, given_range, relative = FALSE) {
full_matrix_checks(pres_matrix, dist_matrix)
if (!is.numeric(given_range) | is.na(given_range)) {
stop("'given_range' argument should be non-null and numeric")
}
if (!is.logical(relative) | is.na(relative) | length(relative) != 1) {
stop("'relative' argument should be either TRUE or FALSE")
}
common = species_in_common(pres_matrix, dist_matrix)
pres_matrix = pres_matrix[, common, drop = FALSE]
dist_matrix = dist_matrix[common, common]
if (!is_relative(pres_matrix)) {
warning("Provided object may not contain relative abundances nor ",
"presence-absence\n",
"Have a look at the make_relative() function if it is the case")
}
corr_matrix = dist_matrix
corr_matrix[dist_matrix > given_range] = 0
corr_matrix[dist_matrix <= given_range] = 1
diag(corr_matrix) = 0
index_matrix = pres_matrix %*% (dist_matrix * corr_matrix)
if (requireNamespace("Matrix", quietly = TRUE) &
is(pres_matrix, "sparseMatrix")) {
index_matrix[Matrix::which(pres_matrix == 0)] = NA
total_sites = Matrix::rowSums(pres_matrix)
} else {
index_matrix[which(pres_matrix == 0)] = NA
total_sites = rowSums(pres_matrix)
}
denom_matrix = pres_matrix %*% corr_matrix
max_dist = 1
if (relative) {
max_dist = apply(pres_matrix, 1, function(row, d_mat = dist_matrix) {
non_null_sp = names(row[row != 0])
non_null_dist = d_mat[non_null_sp, non_null_sp]
max(non_null_dist)
})
}
right_term = 1
if (is_relative(pres_matrix) & !all(unique(as.vector(pres_matrix)) %in%
c(1, 0))) {
right_term = 1 - denom_matrix
}
index_matrix = ((index_matrix / denom_matrix) * right_term) / max_dist
index_matrix[denom_matrix == 0 & pres_matrix != 0] = 1
dimnames(index_matrix) = dimnames(pres_matrix)
return(index_matrix)
} |
source("incl/start.R")
maxCores <- min(2L, availableCores(methods = "system"))
plan("default")
strategy0 <- plan()
message("*** parseCmdArgs() ...")
args <- parseCmdArgs()
str(args)
options(future.plan = NULL, future.cmdargs = c("-p", 1L))
args <- parseCmdArgs()
str(args)
stopifnot(args$p == 1L)
options(future.plan = NULL, future.cmdargs = c(sprintf("--parallel=%d", maxCores)))
args <- parseCmdArgs()
str(args)
stopifnot(args$p == maxCores)
options(future.plan = NULL, future.cmdargs = c("-p", 1L, sprintf("--parallel=%d", maxCores)))
args <- parseCmdArgs()
str(args)
stopifnot(args$p == maxCores)
options(future.plan = NULL, future.cmdargs = c("-p", 0L))
args <- parseCmdArgs()
stopifnot(is.null(args$p))
res <- tryCatch(parseCmdArgs(), warning = function(w) w)
stopifnot(inherits(res, "warning"))
options(future.plan = NULL, future.cmdargs = c("-p", .Machine$integer.max))
args <- parseCmdArgs()
stopifnot(is.null(args$p))
res <- tryCatch(parseCmdArgs(), warning = function(w) w)
stopifnot(inherits(res, "warning"))
options(future.plan = NULL, future.cmdargs = NULL)
message("*** parseCmdArgs() ... DONE")
message("*** .onLoad() ...")
plan("default")
pkgname <- "future"
message("- .onLoad() w/out command-line options ...")
options(future.plan = NULL, future.cmdargs = NULL)
.onLoad(pkgname, pkgname)
strategy <- plan("next")
print(strategy)
stopifnot(all(class(strategy) == class(strategy0)))
plan("default")
message("- .onLoad() w/out command-line options ... DONE")
message("- .onLoad() w/ -p 1 ...")
options(future.plan = NULL, future.cmdargs = c("-p", 1))
.onLoad(pkgname, pkgname)
strategy <- plan("next")
print(strategy)
default <- getOption("future.plan", "sequential")
if (is.function(default)) default <- class(default)
stopifnot(inherits(strategy, default))
plan("default")
message("- .onLoad() w/ -p 1 ... DONE")
message("- .onLoad() w/ --parallel=1 ...")
plan("default")
options(future.plan = NULL, future.cmdargs = "-parallel=1")
.onLoad(pkgname, pkgname)
strategy <- plan("next")
print(strategy)
default <- getOption("future.plan", "sequential")
if (is.function(default)) default <- class(default)
stopifnot(inherits(strategy, default))
plan("default")
message("- .onLoad() w/ --parallel=1 ... DONE")
message("- .onLoad() w/ -p 2 ...")
options(future.plan = NULL, future.cmdargs = c("-p", 2))
.onLoad(pkgname, pkgname)
strategy <- plan("next")
print(strategy)
if (maxCores >= 2) {
stopifnot(inherits(strategy, "multiprocess"))
} else {
stopifnot(all(class(strategy) == class(strategy0)))
}
plan("default")
message("- .onLoad() w/ -p 2 ... DONE")
message("- .onLoad() w/ -p 0 ...")
options(future.plan = NULL, future.cmdargs = c("-p", 0))
.onLoad(pkgname, pkgname)
strategy <- plan("next")
print(strategy)
stopifnot(all(class(strategy) == class(strategy0)))
plan("default")
message("- .onLoad() w/ -p 0 ... DONE")
message("- .onLoad() w/ -p -1 ...")
options(future.plan = NULL, future.cmdargs = c("-p", -1))
.onLoad(pkgname, pkgname)
strategy <- plan("next")
print(strategy)
stopifnot(all(class(strategy) == class(strategy0)))
plan("default")
message("- .onLoad() w/ -p -1 ... DONE")
message("- .onLoad() w/ -p foo ...")
options(future.plan = NULL, future.cmdargs = c("-p", "foo"))
.onLoad(pkgname, pkgname)
strategy <- plan("next")
print(strategy)
stopifnot(all(class(strategy) == class(strategy0)))
plan("default")
message("- .onLoad() w/ -p foo ... DONE")
message("- .onLoad() w/ R_FUTURE_PLAN = 'multisession' ...")
Sys.setenv(R_FUTURE_PLAN = "multisession")
options(future.plan = NULL, future.cmdargs = NULL)
.onLoad(pkgname, pkgname)
strategy <- plan("next")
print(strategy)
stopifnot(inherits(strategy, "multisession"))
plan("default")
Sys.setenv(R_FUTURE_PLAN = "")
message("- .onLoad() w/ R_FUTURE_PLAN = 'multisession' ... DONE")
message("- .onLoad() w/ future.plan = 'multisession' ...")
options(future.plan = NULL, future.plan = 'multisession', future.cmdargs = NULL)
.onLoad(pkgname, pkgname)
strategy <- plan("next")
print(strategy)
stopifnot(inherits(strategy, "multisession"))
plan("default")
message("- .onLoad() w/ future.plan = 'multisession' ... DONE")
message("- .onLoad() w/ R_FUTURE_PLAN = 'multisession' & -p 1 ...")
Sys.setenv(R_FUTURE_PLAN = "multisession")
options(future.plan = NULL, future.cmdargs = c("-p", 1))
.onLoad(pkgname, pkgname)
strategy <- plan("next")
print(strategy)
stopifnot(inherits(strategy, "multisession"))
plan("default")
Sys.setenv(R_FUTURE_PLAN = "")
message("- .onLoad() w/ R_FUTURE_PLAN = 'multisession' & -p 1 ... DONE")
message("- .onLoad() w/ future.plan = 'multisession' & -p 1 ...")
options(future.plan = 'multisession', future.cmdargs = c("-p", "1"))
.onLoad(pkgname, pkgname)
strategy <- plan("next")
print(strategy)
stopifnot(inherits(strategy, "multisession"))
plan("default")
message("- .onLoad() w/ future.plan = 'multisession' & -p 1 ... DONE")
message("- .onLoad() w/ future.plan = 'multisession' & -p 1 ...")
options(future.plan = multisession, future.cmdargs = c("-p", "1"))
.onLoad(pkgname, pkgname)
strategy <- plan("next")
print(strategy)
stopifnot(inherits(strategy, "multisession"))
plan("default")
message("- .onLoad() w/ future.plan = 'multisession' & -p 1 ... DONE")
options(future.plan = NULL, future.cmdargs = NULL, future.availableCores.system = NULL, future.availableCores.fallback = NULL)
message("*** .onLoad() ... DONE")
message("*** .onAttach() ...")
pkgname <- "future"
message("- .onAttach() w/ option future.startup.loadScript ...")
for (value in list(NULL, FALSE, TRUE)) {
options(future.startup.loadScript = value)
.onAttach(pkgname, pkgname)
}
message("- .onAttach() w/ option future.startup.loadScript ... DONE")
message("- .onAttach() with ./.future.R ...")
pathname <- ".future.R"
xyz <- 0L
cat("xyz <- 42L; cat('ping\n')\n", file = pathname)
.onAttach(pkgname, pkgname)
print(xyz)
stopifnot(is.integer(xyz), xyz >= 0, xyz == 42L)
file.remove(pathname)
message("- .onAttach() with ./.future.R ... DONE")
message("*** .onAttach() ... DONE")
source("incl/end.R") |
inset_element <- function(p, left, bottom, right, top, align_to = 'panel', on_top = TRUE, clip = TRUE, ignore_tag = FALSE) {
align_to <- match.arg(align_to, c('panel', 'plot', 'full'))
if (!is.unit(left)) {
left <- unit(left, 'npc')
}
if (!is.unit(bottom)) {
bottom <- unit(bottom, 'npc')
}
if (!is.unit(right)) {
right <- unit(right, 'npc')
}
if (!is.unit(top)) {
top <- unit(top, 'npc')
}
if (!is.ggplot(p)) {
p <- wrap_elements(full = p, clip = FALSE)
}
if (!is.ggplot(p)) {
p <- wrap_elements(full = p, clip = clip)
}
clip <- if (clip) 'on' else 'off'
attr(p, 'settings') <- list(left = left, bottom = bottom, right = right,
top = top, align_to = align_to, on_top = on_top,
clip = clip, ignore_tag = ignore_tag)
class(p) <- c('inset_patch', class(p))
p
}
is_inset_patch <- function(x) inherits(x, 'inset_patch')
print.inset_patch <- function(x, newpage = is.null(vp), vp = NULL, ...) {
print(plot_spacer() + x, newpage = newpage, vp = vp, ...)
}
plot.inset_patch <- print.inset_patch
has_tag.inset_patch <- function(x) !attr(x, 'settings')$ignore_tag |
context("elevation: geonames_conn internal fxn")
test_that("geonames_conn internal fxn works", {
skip_on_cran()
latitude <- c(50.01, 51.01)
longitude <- c(10.2, 11.2)
vcr::use_cassette("elevation_geonames_conn", {
aa <- geonames_conn("srtm3", latitude, longitude)
})
expect_is(aa, "numeric")
expect_equal(length(aa), 2)
})
test_that("geonames_conn fails well", {
skip_on_cran()
expect_error(geonames_conn(), "argument \"elevation_model\" is missing")
expect_error(geonames_conn("foobar"), "argument \"latitude\" is missing")
expect_error(geonames_conn("foobar", 4), "argument \"longitude\" is missing")
vcr::use_cassette("elevation_geonames_conn_unauthorized", {
expect_error(geonames_conn("srtm3", 4, 5, "cheesemonkey"),
"Unauthorized", class = "error")
expect_error(geonames_conn("srtm3", "a", "a"), "invalid number")
})
})
context("elevation")
test_that("elevation", {
skip_on_cran()
load("elevation_test_data.rda")
vcr::use_cassette("elevation", {
aa <- elevation(elevation_test_data)
bb <- elevation(latitude = elevation_test_data$decimalLatitude,
longitude = elevation_test_data$decimalLongitude)
pairs <- list(c(31.8496, -110.576060), c(29.15503, -103.59828))
cc <- elevation(latlong = pairs)
})
expect_is(aa, "data.frame")
expect_is(bb, "data.frame")
expect_is(cc, "data.frame")
expect_is(aa$elevation, "numeric")
expect_is(bb$elevation, "numeric")
expect_is(cc$elevation, "numeric")
})
context("elevation: different elevation models work")
test_that("elevation models work", {
skip_on_cran()
load("elevation_test_data.rda")
eltest_small <- elevation_test_data[1:5, ]
vcr::use_cassette("elevation_models", {
srtm3 <- elevation(eltest_small, elevation_model = "srtm3")
srtm1 <- elevation(eltest_small, elevation_model = "srtm1")
astergdem <- elevation(eltest_small, elevation_model = "astergdem")
gtopo30 <- elevation(eltest_small, elevation_model = "gtopo30")
})
expect_is(srtm3, "data.frame")
expect_is(srtm3$elevation_geonames, "numeric")
expect_is(srtm1, "data.frame")
expect_is(srtm1$elevation_geonames, "numeric")
expect_is(astergdem, "data.frame")
expect_is(astergdem$elevation_geonames, "numeric")
expect_is(gtopo30, "data.frame")
expect_is(gtopo30$elevation_geonames, "numeric")
})
context("elevation: fails well")
test_that("fails correctly", {
skip_on_cran()
expect_error(elevation("aa"), "input must be a data.frame")
expect_error(elevation(), "one of input, lat & long, or latlong must be given")
dat <- data.frame(decimalLatitude = c(6, NA),
decimalLongitude = c(120, -120))
expect_error(elevation(dat), "Input data has some missing values")
dat <- data.frame(decimalLatitude = c(6, 600),
decimalLongitude = c(120, -120))
expect_error(elevation(dat), "Input data has some impossible values")
dat <- data.frame(decimalLatitude = c(0, 45), decimalLongitude = c(0, -120))
vcr::use_cassette("elevation_warning_zero_zero", {
expect_warning(elevation(dat), "Input data has some points at 0,0")
})
pairs <- list(c(31.8496, -110.576060), c(29.15503, -103.59828))
vcr::use_cassette("elevation_unauthorized", {
expect_error(elevation(latlong = pairs, username = "bad_user"),
"Unauthorized", class = "error")
})
}) |
check.arg <-
function(arg, choices, what = "", n = length(arg), value = T){
index <- T
if(length(arg) > n) {
warning(paste("Only the first", n, "values tested in",
deparse(substitute(arg)), "!\n"))
arg <- arg[1:n]
}
while(index) {
index <- pmatch(arg, choices, F, duplicates.ok = T)
if(!all(index)) {
cat("Sorry, it seems you have wrong argument(s)! in ",
deparse(substitute(arg)), " ...\n")
arg <- enter(deparse(substitute(arg)), choices, what = what, n = n)
index <- 1
}
else break
}
if(value) choices[index]
else index
} |
slca_calc_ic <- function( dev, dat, G, K, TP,I, delta.designmatrix, delta.fixed,
Xlambda, Xlambda.fixed, data0, deltaNULL, Xlambda.constr.V,
regularization, regular_indicator_parameters, Xlambda_positive)
{
ic <- list( "deviance"=dev, "n"=nrow(data0) )
ic$traitpars <- 0
ic$itempars <- 0
ic$itempars <- length(Xlambda)
if ( ! is.null(Xlambda.fixed ) ){
ic$itempars <- ic$itempars - nrow(Xlambda.fixed )
}
ind_regular <- ( Xlambda==0 ) * regular_indicator_parameters
ind_positive <- ( Xlambda==0 ) * Xlambda_positive
ind_nonactive <- 1 * ( ind_regular | ind_positive )
ic$nonactive <- sum(ind_nonactive)
ic$itempars <- ic$itempars - ic$nonactive
if ( ! is.null( Xlambda.constr.V ) ){
ic$itempars <- ic$itempars - ncol(Xlambda.constr.V )
}
ic$traitpars <- G * ncol(delta.designmatrix ) - G*deltaNULL
if ( ! is.null(delta.fixed ) ){
ic$traitpars <- ic$traitpars - nrow(delta.fixed )
}
ic$np <- ic$itempars + ic$traitpars
ic <- cdm_calc_information_criteria(ic=ic)
return(ic)
}
.slca.calc.ic <- slca_calc_ic |
summary.fit.linERR <-
function (object, ...)
{
call <- attr(object, "Call")
coef.p <- attr(object,"details")$par
var.cf <- diag(attr(object, "vcov"))
dn <- c("Estimate", "Std. Error")
s.err <- vector()
tvalue <- vector()
pvalue <- vector()
names.covs <- c(colnames(attr(object, "covariates1")), attr(object, "covs_names"))
if (!all(var.cf > 0))
{
warning("Hessian is not positive definite")
}
for (i in 1:length(coef.p))
{
if (var.cf[i] > 0)
{
s.err[i] <- sqrt(var.cf[i])
tvalue[i] <- coef.p[i]/s.err[i]
pvalue[i] <- 2 * pnorm(-abs(tvalue[i]))
}else{
s.err[i] <- NA
tvalue[i] <- NA
pvalue[i] <- NA
}
}
coef.table <- cbind(coef.p, s.err, tvalue, pvalue)
dimnames(coef.table) <- list(names(coef.p), c(dn, "Test Stat.", "p-value"))
rownames(coef.table) <- c("dose", names.covs)
aic <- attr(object, "aic")
dev <- attr(object, "deviance")
inf.rsets <- length(attr(object, "rsets_2")) - 1
ans <- list(coefficients=coef.table, aic=aic, dev=dev, call=call, inf.rsets=inf.rsets)
class(ans) <- "summary.fit.linERR"
return(ans)
} |
rMVNmixture2 <- function(n, weight, mean, Q, Sigma)
{
thispackage <- "mixAK"
if (n <= 0) stop("n must be positive")
if (any(weight < 0)) stop("weights must be non-negative")
K <- length(weight)
if (K == 0) stop("weight is of zero length")
weight <- weight/sum(weight)
UNIVARIATE <- FALSE
if (!is.matrix(mean)) UNIVARIATE <- TRUE
else if (ncol(mean) == 1) UNIVARIATE <- TRUE
if (UNIVARIATE){
p <- 1
if (length(mean) != K) stop(paste("mean must be of length ", K, sep=""))
if (missing(Sigma)){
if (missing(Q)) stop("Sigma or Q must be given")
if (length(Q) != K) stop(paste("Q must be of length ", K, sep=""))
if (is.list(Q)){
lQ <- sapply(Q, length)
if (any(lQ != 1)) stop("all Q elements must be of length 1")
Q <- unlist(Q)
}
if (any(Q <= 0)) stop("all Q elements must be positive")
degener <- is.infinite(Q)
Sigma <- 1/Q
}else{
if (length(Sigma) != K) stop(paste("Sigma must be of length ", K, sep=""))
if (is.list(Sigma)){
lSigma <- sapply(Sigma, length)
if (any(lSigma != 1)) stop("all Sigma elements must be of length 1")
Sigma <- unlist(Sigma)
}
if (any(Sigma < 0)) stop("all Sigma elements must be nonnegative")
degener <- (Sigma==0)
Q <- 1/Sigma
}
}else{
p <- ncol(mean)
if (nrow(mean) != K) stop(paste("mean must have ", K, " rows", sep=""))
if (missing(Sigma)){
if (missing(Q)) stop("Sigma or Q must be given")
if (is.matrix(Q)){
if (K != 1) stop("Q must be a list of matrices")
Q <- list(Q)
}
if (length(Q) != K) stop(paste("Q must be of length ", K, sep=""))
Sigma <- list()
QLT <- numeric(0)
for (j in 1:K){
if (!is.matrix(Q[[j]])) stop("all elements of Q must be matrices")
if (nrow(Q[[j]]) != p | ncol(Q[[j]]) != p) stop(paste("all elements of Q must be squared matrices with ", p, " rows and columns", sep=""))
Sigma[[j]] <- chol2inv(chol(Q[[j]]))
QLT <- c(QLT, Q[[j]][lower.tri(Q[[j]], diag=TRUE)])
}
}else{
if (is.matrix(Sigma)){
if (K != 1) stop("Sigma must be a list of matrices")
Sigma <- list(Sigma)
}
if (length(Sigma) != K) stop(paste("Sigma must be of length ", K, sep=""))
Q <- list()
QLT <- numeric(0)
for (j in 1:K){
if (!is.matrix(Sigma[[j]])) stop("all elements of Sigma must be matrices")
if (nrow(Sigma[[j]]) != p | ncol(Sigma[[j]]) != p) stop(paste("all elements of Sigma must be squared matrices with ", p, " rows and columns", sep=""))
Q[[j]] <- chol2inv(chol(Sigma[[j]]))
QLT <- c(QLT, Q[[j]][lower.tri(Q[[j]], diag=TRUE)])
}
}
}
if (p == 1){
SAMPLE <- .C(C_rmixNorm_R, x = double(n),
dens = double(n),
cumw = double(K),
K = as.integer(K),
w = as.double(weight),
mu = as.double(mean),
sigma = as.double(sqrt(Sigma)),
npoints= as.integer(n),
PACKAGE=thispackage)
x <- SAMPLE$x
}else{
SAMPLE <- .C(C_rmixMVN_R, x = double(p*n),
dens = double(n),
w.dets = as.double(weight),
cumw = double(K),
Li = as.double(QLT),
work = double(p),
err = integer(1),
K = as.integer(K),
mu = as.double(t(mean)),
nx = as.integer(p),
npoints= as.integer(n),
PACKAGE=thispackage)
if (SAMPLE$err) stop("Something went wrong.")
x <- matrix(SAMPLE$x, nrow=n, ncol=p, byrow=TRUE)
}
return(list(x=x, dens=SAMPLE$dens))
} |
`XY.GLOB` <-
function(x, y, PROJ.DATA)
{
if(PROJ.DATA$type==0)
{
LL = list(lon=x , lat=y)
}
if(PROJ.DATA$type==1)
{
LL = merc.sphr.ll(PROJ.DATA$LON0 , x , y)
}
if(PROJ.DATA$type==2)
{
LL = utm.sphr.ll( x , y, PROJ.DATA)
}
if(PROJ.DATA$type==3)
{
LL = lambert.cc.ll( x , y, PROJ.DATA)
}
if(PROJ.DATA$type==4)
{
LL = stereo.sphr.ll( x , y, PROJ.DATA)
}
if(PROJ.DATA$type==5)
{
LL = utm.elps.ll( x , y, PROJ.DATA)
}
if(PROJ.DATA$type==6)
{
LL = equid.cyl.ll(PROJ.DATA$LON0 ,PROJ.DATA$LAT0 , x , y)
}
if(PROJ.DATA$type==7)
{
LL = utm.wgs84.ll( x , y, PROJ.DATA)
}
if(PROJ.DATA$type==99)
{
LL = lcgc(PROJ.DATA$LAT0, PROJ.DATA$LON0, x , y)
}
return(LL)
} |
structure(list(url = "https://api.twitter.com/2/users?ids=1085578910853746688%2C2758518175%2C34739420&user.fields=created_at%2Cdescription%2Centities%2Cid%2Clocation%2Cname%2Cpinned_tweet_id%2Cprofile_image_url%2Cprotected%2Cpublic_metrics%2Curl%2Cusername%2Cverified%2Cwithheld",
status_code = 200L, headers = structure(list(date = "Wed, 16 Jun 2021 19:52:44 UTC",
server = "tsa_o", `content-type` = "application/json; charset=utf-8",
`cache-control` = "no-cache, no-store, max-age=0", `content-length` = "1014",
`x-access-level` = "read", `x-frame-options` = "SAMEORIGIN",
`content-encoding` = "gzip", `x-xss-protection` = "0",
`x-rate-limit-limit` = "900", `x-rate-limit-reset` = "1623874064",
`content-disposition` = "attachment; filename=json.json",
`x-content-type-options` = "nosniff", `x-rate-limit-remaining` = "899",
`strict-transport-security` = "max-age=631138519", `x-connection-hash` = "6a7945024491d2dfb78c94f690b6bff88f3d5503d394391ff4122326cd6e676b"), class = c("insensitive",
"list")), all_headers = list(list(status = 200L, version = "HTTP/2",
headers = structure(list(date = "Wed, 16 Jun 2021 19:52:44 UTC",
server = "tsa_o", `content-type` = "application/json; charset=utf-8",
`cache-control` = "no-cache, no-store, max-age=0",
`content-length` = "1014", `x-access-level` = "read",
`x-frame-options` = "SAMEORIGIN", `content-encoding` = "gzip",
`x-xss-protection` = "0", `x-rate-limit-limit` = "900",
`x-rate-limit-reset` = "1623874064", `content-disposition` = "attachment; filename=json.json",
`x-content-type-options` = "nosniff", `x-rate-limit-remaining` = "899",
`strict-transport-security` = "max-age=631138519",
`x-connection-hash` = "6a7945024491d2dfb78c94f690b6bff88f3d5503d394391ff4122326cd6e676b"), class = c("insensitive",
"list")))), cookies = structure(list(domain = c(".twitter.com",
".twitter.com"), flag = c(TRUE, TRUE), path = c("/", "/"),
secure = c(TRUE, TRUE), expiration = structure(c(1686941991,
1686941991), class = c("POSIXct", "POSIXt")), name = c("personalization_id",
"guest_id"), value = c("REDACTED", "REDACTED")), row.names = c(NA,
-2L), class = "data.frame"), content = charToRaw("{\"data\":[{\"description\":\"Doctoral student @IWMtue. Research on mobile & social media use, coping with stress & media use in the family. Tweets about research and academic parenting.\",\"name\":\"Lara Wolfers\",\"public_metrics\":{\"followers_count\":363,\"following_count\":499,\"tweet_count\":438,\"listed_count\":4},\"id\":\"1085578910853746688\",\"profile_image_url\":\"https://pbs.twimg.com/profile_images/1085579140911296512/q488WZrd_normal.jpg\",\"pinned_tweet_id\":\"1287691621010636803\",\"username\":\"LaraWolfers\",\"protected\":false,\"entities\":{\"url\":{\"urls\":[{\"start\":0,\"end\":23,\"url\":\"https://t.co/I6inXyQHR2\",\"expanded_url\":\"https://www.iwm-tuebingen.de/www/en/personen/ma.html?uid=lwolfers\",\"display_url\":\"iwm-tuebingen.de/www/en/persone…\"}]},\"description\":{\"mentions\":[{\"start\":17,\"end\":24,\"username\":\"IWMtue\"}]}},\"verified\":false,\"created_at\":\"2019-01-16T16:45:56.000Z\",\"url\":\"https://t.co/I6inXyQHR2\"},{\"description\":\"Asst. Prof at S3H @Official_NUST | Alum @IfMk | Tweets about
date = structure(1623873164, class = c("POSIXct", "POSIXt"
), tzone = "GMT"), times = c(redirect = 0, namelookup = 0.04271,
connect = 0.055917, pretransfer = 0.092674, starttransfer = 0.352535,
total = 0.352721)), class = "response") |
context("createLocalList")
test_that("everything works when arguments are given", {
testy <- rnorm(50)
testfilter <- lowpassFilter::lowpassFilter(type = "bessel", param = list(pole = 4, cutoff = 0.1), sr = 1e4)
testlengths <- 3:4
testlocalList <- createLocalList(filter = testfilter, method = "LR", lengths = testlengths)
expect_is(testlocalList, "localList")
expect_true(is.list(testlocalList))
expect_identical(length(testlocalList), length(testlengths))
expect_identical(attr(testlocalList, "method"), "LR")
expect_identical(attr(testlocalList, "filter"), testfilter)
expect_identical(attr(testlocalList, "lengths"), testlengths)
expect_error(stepR::critVal(50L, alpha = 0.1, stat = teststat, family = "LR",
filter = testfilter, lengths = testlengths, localList = 1))
expect_error(stepR::computeStat(testy, family = "LR", filter = testfilter, lengths = testlengths,
localList = list()))
expect_identical(stepR::computeStat(testy, family = "LR", filter = testfilter, lengths = testlengths),
stepR::computeStat(testy, family = "LR", filter = testfilter, lengths = testlengths,
localList = testlocalList))
expect_identical(stepR::monteCarloSimulation(family = "LR", n = 50L, r = 2L, filter = testfilter,
lengths = testlengths, output = "maximum"),
stepR::monteCarloSimulation(family = "LR", n = 50L, r = 2L, filter = testfilter,
lengths = testlengths, output = "maximum",
localList = testlocalList))
testlocalList <- createLocalList(filter = testfilter, method = "LR")
expect_identical(stepR::monteCarloSimulation(family = "LR", n = 35L, r = 2L, filter = testfilter),
stepR::monteCarloSimulation(family = "LR", n = 35L, r = 2L, filter = testfilter,
localList = testlocalList))
teststat <- stepR::monteCarloSimulation(35L, r = 10L, family = "LR", filter = testfilter)
expect_identical(stepR::critVal(35L, alpha = 0.1, stat = teststat, family = "LR", filter = testfilter),
stepR::critVal(35L, alpha = 0.1, stat = teststat, family = "LR", filter = testfilter,
localList = testlocalList))
expect_equal(stepR::critVal(35L, alpha = 0.1, stat = teststat, family = "LR", filter = testfilter),
stepR::critVal(35L, alpha = 0.1, r = 10, family = "LR", filter = testfilter,
localList = testlocalList))
testfilter <- lowpassFilter::lowpassFilter(type = "bessel", param = list(pole = 4, cutoff = 0.1), sr = 1e4)
testlocalList <- clampSeg::createLocalList(filter = testfilter, method = "LR")
teststat <- stepR::monteCarloSimulation(35L, r = 10L, family = "LR", filter = testfilter)
expect_equal(stepR::critVal(35L, alpha = 0.1, stat = teststat, family = "LR", filter = testfilter,
options = list(load = list())),
stepR::critVal(35L, alpha = 0.1, r = 10, family = "LR", filter = testfilter,
localList = testlocalList,
options = list(load = list(), simulation = "matrix")))
testlocalList <- createLocalList(filter = testfilter, method = "2Param", lengths = testlengths)
expect_is(testlocalList, "localList")
expect_true(is.list(testlocalList))
expect_identical(length(testlocalList), length(testlengths))
expect_identical(attr(testlocalList, "method"), "2Param")
expect_identical(attr(testlocalList, "filter"), testfilter)
expect_identical(attr(testlocalList, "lengths"), testlengths)
expect_identical(stepR::computeStat(testy, family = "2Param", filter = testfilter, lengths = testlengths),
stepR::computeStat(testy, family = "2Param", filter = testfilter, lengths = testlengths,
localList = testlocalList))
expect_identical(stepR::monteCarloSimulation(family = "2Param", n = 50L, r = 2L, filter = testfilter,
lengths = testlengths, output = "maximum"),
stepR::monteCarloSimulation(family = "2Param", n = 50L, r = 2L, filter = testfilter,
lengths = testlengths, output = "maximum",
localList = testlocalList))
expect_error(stepR::computeStat(testy, family = "2Param", filter = testfilter, lengths = testlengths,
localList = 1))
expect_error(stepR::computeStat(testy, family = "2Param", filter = testfilter, lengths = testlengths,
localList = list()))
expect_error(stepR::computeStat(testy, family = "2Param", filter = testfilter, lengths = testlengths,
localList = unclass(testlocalList)))
})
test_that("filter is tested and works", {
testy <- rnorm(50)
testfilter <- lowpassFilter::lowpassFilter(type = "bessel", param = list(pole = 6, cutoff = 0.2), sr = 1e4)
testlengths <- 5
expect_error(createLocalList())
expect_error(createLocalList(method = "LR", lengths = testlengths))
expect_error(createLocalList(filter = list(test = 1), method = "LR", lengths = testlengths))
expect_error(createLocalList(filter = unclass(testfilter), method = "LR", lengths = testlengths))
testlocalList <- createLocalList(filter = testfilter, method = "LR", lengths = testlengths)
expect_identical(attr(testlocalList, "filter"), testfilter)
testfilter2 <- lowpassFilter::lowpassFilter(type = "bessel", param = list(pole = 4, cutoff = 0.1), sr = 1e4)
expect_error(stepR::computeStat(testy, family = "LR", filter = testfilter2, lengths = testlengths,
localList = testlocalList))
expect_identical(stepR::computeStat(testy, family = "LR", filter = testfilter, lengths = testlengths),
stepR::computeStat(testy, family = "LR", filter = testfilter, lengths = testlengths,
localList = testlocalList))
testlocalList <- createLocalList(filter = testfilter, method = "2Param", lengths = testlengths)
expect_error(stepR::computeStat(testy, family = "2Param", filter = testfilter2, lengths = testlengths,
localList = testlocalList))
expect_identical(stepR::computeStat(testy, family = "2Param", filter = testfilter, lengths = testlengths),
stepR::computeStat(testy, family = "2Param", filter = testfilter, lengths = testlengths,
localList = testlocalList))
})
test_that("method is tested and works", {
testy <- rnorm(50)
testfilter <- lowpassFilter::lowpassFilter(type = "bessel", param = list(pole = 4, cutoff = 0.075), sr = 1e4)
testlengths <- c(2, 7)
expect_error(createLocalList(filter = testfilter, method = Inf, lengths = testlengths))
expect_error(createLocalList(filter = testfilter, method = "s", lengths = testlengths))
expect_error(createLocalList(filter = testfilter, method = "2L", lengths = testlengths))
expect_error(createLocalList(filter = testfilter, method = "", lengths = testlengths))
testlocalList <- createLocalList(filter = testfilter, method = "LR", lengths = testlengths)
expect_error(stepR::computeStat(testy, family = "2Param", filter = testfilter, lengths = testlengths,
localList = testlocalList))
testlocalList <- createLocalList(filter = testfilter, lengths = testlengths)
expect_error(stepR::computeStat(testy, family = "LR", filter = testfilter, lengths = testlengths,
localList = testlocalList))
expect_identical(stepR::computeStat(testy, family = "2Param", filter = testfilter, lengths = testlengths),
stepR::computeStat(testy, family = "2Param", filter = testfilter, lengths = testlengths,
localList = testlocalList))
})
test_that("lengths is tested and works", {
testy <- rnorm(50)
testfilter <- lowpassFilter::lowpassFilter(type = "bessel", param = list(pole = 6, cutoff = 0.2), sr = 1e4)
testlengths <- c(3, 8:9)
testlocalList <- createLocalList(filter = testfilter, method = "LR", lengths = testlengths)
expect_error(createLocalList(filter = testfilter, method = "LR", lengths = NULL))
expect_error(createLocalList(filter = testfilter, method = "LR", lengths = c(3, "s", 4)))
expect_error(createLocalList(filter = testfilter, method = "LR", lengths = 0L))
expect_error(createLocalList(filter = testfilter, method = "LR", lengths = c(-1L, 10L)))
expect_error(createLocalList(filter = testfilter, method = "LR", lengths = c(5L, Inf)))
expect_identical(createLocalList(filter = testfilter, method = "LR", lengths = c(9, 3, 8)), testlocalList)
expect_identical(createLocalList(filter = testfilter, method = "LR", lengths = c(3.2, 8.1, 9.3)), testlocalList)
expect_warning(ret <- createLocalList(filter = testfilter, method = "LR", lengths = c(3.2, 8.1, 9.1, 9.3, 3.6)))
expect_identical(ret, testlocalList)
expect_identical(createLocalList(filter = testfilter, method = "LR", lengths = 1:20),
createLocalList(filter = testfilter, method = "LR"))
expect_error(stepR::computeStat(testy, family = "LR", filter = testfilter, lengths = c(4, 5),
localList = testlocalList))
expect_identical(stepR::computeStat(testy, family = "LR", filter = testfilter, lengths = testlengths),
stepR::computeStat(testy, family = "LR", filter = testfilter, lengths = testlengths,
localList = testlocalList))
testlocalList <- createLocalList(filter = testfilter, method = "2Param", lengths = testlengths)
expect_error(stepR::computeStat(testy, family = "2Param", filter = testfilter,
localList = testlocalList))
expect_identical(stepR::computeStat(testy, family = "2Param", filter = testfilter, lengths = testlengths),
stepR::computeStat(testy, family = "2Param", filter = testfilter, lengths = testlengths,
localList = testlocalList))
})
test_that("it is compatibel with other arguments when passed to stepR functions", {
testn <- 100L
testfilter <- lowpassFilter::lowpassFilter(type = "bessel", param = list(pole = 4, cutoff = 0.1), sr = 1)
testy <- lowpassFilter::randomGenerationMA(n = testn, filter = testfilter, seed = "no")
testlengths <- c(1, 2, 4, 8, 16)
testlocalList <- createLocalList(filter = testfilter, method = "LR", lengths = testlengths)
testfit <- stepR::stepblock(c(0, 1), leftEnd = c(0, 50 / testfilter$sr) - 10,
rightEnd = c(50 / testfilter$sr, testn / testfilter$sr) -10, x0 = -10)
expect_identical(stepR::computeStat(testy, family = "LR", filter = testfilter, fit = testfit,
intervalSystem = "dyaLen", penalty = "sqrt", nq = 120L,
thresholdLongSegment = 8L, localValue = mean, startTime = -10,
regularization = c(1, 0.5),
suppressWarningNoDeconvolution = TRUE),
stepR::computeStat(testy, family = "LR", filter = testfilter, fit = testfit,
intervalSystem = "dyaLen", penalty = "sqrt", nq = 120L,
thresholdLongSegment = 8L, localValue = mean, startTime = -10,
regularization = c(1, 0.5),
suppressWarningNoDeconvolution = TRUE, localList = testlocalList))
expect_identical(stepR::monteCarloSimulation(family = "LR", n = 35L, r = 2L, filter = testfilter, seed = 34L,
intervalSystem = "dyaLen", rand.gen = function(data) rnorm(data$n),
thresholdLongSegment = 5L, localValue = mean, startTime = -10,
regularization = c(0.5), suppressWarningNoDeconvolution = TRUE),
stepR::monteCarloSimulation(family = "LR", n = 35L, r = 2L, filter = testfilter, seed = 34L,
intervalSystem = "dyaLen", rand.gen = function(data) rnorm(data$n),
thresholdLongSegment = 5L, localValue = mean, startTime = -10,
suppressWarningNoDeconvolution = TRUE, regularization = c(0.5),
localList = testlocalList))
teststat <- stepR::monteCarloSimulation(n = 100L, r = 10L, family = "LR", filter = testfilter)
expect_equal(stepR::critVal(alpha = 0.125, n = 80L, stat = teststat, nq = 100L, family = "LR",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
thresholdLongSegment = 5L, localValue = mean, startTime = -10,
regularization = c(0.5),
penalty = "sqrt", output = "value"),
stepR::critVal(alpha = 0.125, n = 80L, stat = teststat, nq = 100L, family = "LR",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
thresholdLongSegment = 5L, localValue = mean, startTime = -10,
regularization = c(0.5),
penalty = "sqrt", output = "value", localList = testlocalList))
expect_equal(stepR::critVal(alpha = 0.075, n = 90L, stat = teststat, nq = 100L, family = "LR",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
penalty = "log", output = "value", startTime = -10),
stepR::critVal(alpha = 0.075, n = 90L, r = 10L, nq = 100L, family = "LR",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
options = list(simulation = "vectorIncreased", save = list(), load = list()),
penalty = "log", output = "value", startTime = -10, localList = testlocalList))
testy <- lowpassFilter::randomGenerationMA(n = testn, filter = testfilter, seed = "no")
testfit <- stepR::stepblock(c(0, 1, 0), leftEnd = c(0, 50 / testfilter$sr, 53 / testfilter$sr),
rightEnd = c(50 / testfilter$sr, 53 / testfilter$sr, testn / testfilter$sr), x0 = 0)
compare <- stepR::computeStat(y = testy, family = "LR", filter = testfilter, fit = testfit, lengths = testlengths)
expect_identical(stepR::computeStat(y = testy, filter = testfilter, family = "LR", fit = testfit,
lengths = testlengths, localList = testlocalList), compare)
expect_identical(stepR::computeStat(y = testy, filter = testfilter, family = "LR", fit = testfit,
lengths = testlengths, localList = testlocalList,
output = "maximum"), compare$maximum)
expect_identical(stepR::computeStat(y = testy, filter = testfilter, family = "LR", fit = testfit,
lengths = testlengths, localList = testlocalList,
output = "vector"), compare$stat)
testlengths <- c(3, 5)
testlocalList <- createLocalList(filter = testfilter, method = "2Param", lengths = testlengths)
expect_identical(stepR::computeStat(testy, family = "2Param", filter = testfilter, fit = testfit,
intervalSystem = "all", penalty = "log", nq = 120L, lengths = testlengths,
thresholdLongSegment = 13L, localValue = function(x) 1,
localVar = sd, regularization = c(0.8), suppressWarningNoDeconvolution = TRUE),
stepR::computeStat(testy, family = "2Param", filter = testfilter, fit = testfit,
penalty = "log", nq = 120L, lengths = testlengths,
thresholdLongSegment = 13L, localValue = function(x) 1,
localVar = sd, regularization = c(0.8), suppressWarningNoDeconvolution = TRUE,
localList = testlocalList))
expect_identical(stepR::monteCarloSimulation(family = "2Param", n = 75L, r = 2L, filter = testfilter, seed = 14L,
output = "maximum", penalty = "log", lengths = testlengths,
intervalSystem = "all", rand.gen = function(data) rnorm(data$n) + 1,
thresholdLongSegment = 7L, localValue = function(x) mean(x) - 1,
suppressWarningNoDeconvolution = TRUE),
stepR::monteCarloSimulation(family = "2Param", n = 75L, r = 2L, filter = testfilter, seed = 14L,
output = "maximum", penalty = "log", lengths = testlengths,
rand.gen = function(data) rnorm(data$n) + 1,
thresholdLongSegment = 7L, localValue = function(x) mean(x) - 1,
suppressWarningNoDeconvolution = TRUE,
localList = testlocalList))
teststat <- stepR::monteCarloSimulation(n = 100L, r = 2L, family = "2Param", filter = testfilter,
output = "maximum", lengths = testlengths, localList = testlocalList,
penalty = "log")
expect_equal(stepR::critVal(alpha = 0.33, n = 80L, r = 2L, nq = 100L, family = "2Param",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
penalty = "log"),
stepR::critVal(alpha = 0.335, n = 80L, stat = teststat, nq = 100L, family = "2Param",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
penalty = "log", localList = testlocalList))
testn <- 100L
testfilter <- lowpassFilter::lowpassFilter(type = "bessel", param = list(pole = 4, cutoff = 0.1), sr = 1e4)
testy <- lowpassFilter::randomGenerationMA(n = testn, filter = testfilter, seed = "no")
testfit <- stepR::stepblock(0, leftEnd = 0, rightEnd = testn / testfilter$sr, x0 = 0)
testlengths <- c(1, 2, 4, 8, 16)
testlocalList <- createLocalList(filter = testfilter, method = "LR", lengths = testlengths)
teststat <- stepR::monteCarloSimulation(n = 100L, r = 10L, family = "LR", filter = testfilter)
expect_equal(stepR::critVal(alpha = 0.075, n = 90L, stat = teststat, nq = 100L, family = "LR",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
penalty = "log", output = "value"),
stepR::critVal(alpha = 0.075, n = 90L, r = 10L, nq = 100L, family = "LR",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
options = list(simulation = "matrixIncreased", save = list(), load = list()),
penalty = "log", output = "value", localList = testlocalList))
expect_equal(stepR::critVal(alpha = 0.175, n = 100L, stat = teststat, family = "LR",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
penalty = "sqrt", output = "value"),
stepR::critVal(alpha = 0.175, n = 100L, r = 10L, family = "LR",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
options = list(simulation = "matrix", save = list(), load = list()),
penalty = "sqrt", output = "value", localList = testlocalList))
expect_equal(stepR::critVal(alpha = 0.075, n = 90L, stat = teststat, nq = 100L, family = "LR",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
output = "vector"),
stepR::critVal(alpha = 0.075, n = 90L, r = 10L, nq = 100L, family = "LR",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
options = list(simulation = "matrixIncreased", save = list(), load = list()),
output = "vector", localList = testlocalList))
expect_equal(stepR::critVal(alpha = 0.175, n = 100L, stat = teststat, family = "LR",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
output = "vector"),
stepR::critVal(alpha = 0.175, n = 100L, r = 10L, family = "LR",
filter = testfilter, intervalSystem = "all", lengths = testlengths,
options = list(simulation = "matrix", save = list(), load = list()),
output = "vector", localList = testlocalList))
}) |
summary.rocit<- function(object, ... = NULL)
{
msg <- NULL
msg <- c(msg, paste("Method used:", object$method))
msg <- c(msg, paste("Number of positive(s):", object$pos_count))
msg <- c(msg, paste("Number of negative(s):", object$neg_count))
msg <- c(msg, paste("Area under curve:", round(object$AUC, 4)))
pdf <- data.frame(msg)
names(pdf) <- NULL
print(pdf, row.names = FALSE, right = FALSE, quote = FALSE)
} |
install_theme <- function(menus = TRUE) {
if(!rstudioapi::isAvailable()) stop("RSCodeio must be installed from within RStudio.")
if(utils::compareVersion(as.character(rstudioapi::versionInfo()$version), "1.2.0") < 0)
stop("You need RStudio 1.2 or greater to get theme support")
if(rscodeio_installed()){
uninstall_theme()
}
rscodeio_default_theme <- rstudioapi::addTheme(fs::path_package(package = "rscodeio",
"resources","rscodeio.rstheme"))
rstudioapi::addTheme(fs::path_package(package = "rscodeio",
"resources","rscodeio_tomorrow_night_bright.rstheme"))
if (menus) activate_menu_theme()
rstudioapi::applyTheme(rscodeio_default_theme)
}
uninstall_theme <- function(){
deactivate_menu_theme()
installed_rscodeio_themes <- grep(x = purrr::map_depth(.x = rstudioapi::getThemes(),
.depth = 1L,
.f = purrr::pluck("name")),
pattern = "rscodeio",
value = TRUE)
for (theme in installed_rscodeio_themes) {
rstudioapi::removeTheme(theme)
}
}
activate_menu_theme <- function() {
if(host_os_is_mac() | is_rstudio_server()) return(NULL)
if(file.exists(gnome_theme_dark_backup()) |
file.exists(windows_theme_dark_backup())) {
message("RSCodeio menu theme already activated. Deactivate first.")
return(FALSE)
}
file.copy(from = gnome_theme_dark(),
to = gnome_theme_dark_backup())
file.copy(from = windows_theme_dark(),
to = windows_theme_dark_backup())
file.copy(from = system.file(fs::path("resources","stylesheets","rstudio-gnome-dark.qss"),
package = "rscodeio"),
to = gnome_theme_dark(),
overwrite = TRUE)
file.copy(from = system.file(fs::path("resources","stylesheets","rstudio-windows-dark.qss"),
package = "rscodeio"),
to = windows_theme_dark(),
overwrite = TRUE)
}
deactivate_menu_theme <- function(){
if(host_os_is_mac()) return(NULL)
if(!file.exists(gnome_theme_dark_backup()) |
!file.exists(windows_theme_dark_backup())) {
message("RStudio theme backups not found. rscodeio already deactivated?")
return(FALSE)
}
file.copy(from = gnome_theme_dark_backup(),
to = gnome_theme_dark(),
overwrite = TRUE)
file.copy(from = windows_theme_dark_backup(),
to = windows_theme_dark(),
overwrite = TRUE)
unlink(gnome_theme_dark_backup())
unlink(windows_theme_dark_backup())
} |
dbetapr <- function(x, shape1, shape2, scale = 1, log = FALSE) {
cpp_dbetapr(x, shape1, shape2, scale, log[1L])
}
pbetapr <- function(q, shape1, shape2, scale = 1, lower.tail = TRUE, log.p = FALSE) {
cpp_pbetapr(q, shape1, shape2, scale, lower.tail[1L], log.p[1L])
}
qbetapr <- function(p, shape1, shape2, scale = 1, lower.tail = TRUE, log.p = FALSE) {
cpp_qbetapr(p, shape1, shape2, scale, lower.tail[1L], log.p[1L])
}
rbetapr <- function(n, shape1, shape2, scale = 1) {
if (length(n) > 1) n <- length(n)
cpp_rbetapr(n, shape1, shape2, scale)
} |
regzip <- function(pa, y1, x, n1, poia) {
a <- exp(pa[1]) / ( 1 + exp(pa[1]) ) ; b <- pa[-1]
es <- tcrossprod(b, x)
- sum( log( a + (1 - a) * exp( - exp( es[poia]) ) ) ) - n1 * log( 1 - a ) - sum( y1 * es[ -poia ] - exp(es[ -poia ]) )
} |
JackMLSW = function (ysA, ysB, pik_A, pik_B, pik_ab_B, pik_ba_A, domains_A, domains_B, xsA, xsB, x, ind_sam, conf_level, sdA = "srs", sdB = "srs", strA = NULL, strB = NULL, clusA = NULL, clusB = NULL, fcpA = FALSE, fcpB = FALSE){
ysA <- as.data.frame(ysA)
ysB <- as.data.frame(ysB)
xsA <- as.matrix(xsA)
xsB <- as.matrix(xsB)
x <- as.matrix(x)
cl <- match.call()
results <- list()
N <- nrow(x)
c <- ncol(ysA)
estimation <- MLSW(ysA, ysB, pik_A, pik_B, pik_ab_B, pik_ba_A, domains_A, domains_B, xsA, xsB, x, ind_sam)[[2]]
for (l in 1:c) {
ys <- factor(c(as.character(ysA[,l]),as.character(ysB[,l])))
lev <- levels(ys)
m <- length(lev)
nA <- nrow(ysA)
nB <- nrow(ysB)
mat <- matrix(NA, 6, m)
if (sdA == "str"){
strataA <- unique(sort(strA))
nhA <- table(strA)
nstrataA <- length(nhA)
YcstrataA <- matrix(0, nstrataA, m)
nhA <- c(0, nhA)
cnhA <- cumsum(nhA)
for (i in 1:nstrataA){
k <- 1
YcA <- matrix(0, nhA[i+1], m)
for (j in (cnhA[i]+1):cnhA[i+1]){
YcA[k,] <- MLSW(ysA[-j,], ysB, pik_A[-j], pik_B, pik_ab_B[-j], pik_ba_A, domains_A[-j], domains_B, xsA[-j,], xsB, x, ind_sam[-j])[[2]][[l]][1,]
k <- k + 1
}
YcAMean <- matrix(colMeans(YcA), nhA[i+1], m, byrow = TRUE)
if (fcpA)
fA <- 1 - mean(pik_A[strA == strataA[i]])
else
fA <- 1
YcstrataA[i,] <- (nhA[i+1] - 1) / nhA[i+1] * fA * colSums((YcA - YcAMean)^2)
}
vjA <- colSums(YcstrataA)
}
else {
if (sdA == "clu"){
clustersA <- unique(clusA)
probclustersA <- unique(data.frame(pik_A, clusA))[,1]
nclustersA <- length(clustersA)
if (nclustersA < 3)
stop("Number of clusters from frame A is less than 3. Variance cannot be computed.")
YcA <- matrix(0, nclustersA, m)
for (i in 1:nclustersA)
YcA[i,] <- MLSW(ysA[clusA %in% clustersA[-clustersA[i]],], ysB, pik_A[clusA %in% clustersA[-clustersA[i]]], pik_B, pik_ab_B[clusA %in% clustersA[-clustersA[i]]], pik_ba_A, domains_A[clusA %in% clustersA[-clustersA[i]]], domains_B, xsA[clusA %in% clustersA[-clustersA[i]],], xsB, x, ind_sam[c(clusA %in% clustersA[-clustersA[i]], rep(TRUE, nB))])[[2]][[l]][1,]
YcAMean <- matrix(colMeans(YcA), nclustersA, m, byrow = TRUE)
if (fcpA)
fA <- 1 - mean(probclustersA)
else
fA <- 1
vjA <- ((nclustersA - 1) / nclustersA) * fA * colSums ((YcA - YcAMean)^2)
}
else{
if (sdA == "strclu"){
strataA <- unique(sort(strA))
nstrataA <- length(strataA)
YcstrataA <- matrix(0, nstrataA, m)
for (i in 1:nstrataA){
clustersA <- unique(clusA[strA == strataA[i]])
probclustersA <- unique(data.frame(pik_A[strA == strataA[i]], clusA[strA == strataA[i]]))[,1]
nclustersA <- length(clustersA)
if (nclustersA < 3)
stop("Number of clusters in any stratum from frame A is less than 3. Variance cannot be computed.")
k <- 1
YcA <- matrix(0, nclustersA, m)
for (j in 1:nclustersA){
YcA[k,] <- MLSW(ysA[clusA %in% clustersA[-clustersA[j]],], ysB, pik_A[clusA %in% clustersA[-clustersA[j]]], pik_B, pik_ab_B[clusA %in% clustersA[-clustersA[j]]], pik_ba_A, domains_A[clusA %in% clustersA[-clustersA[j]]], domains_B, xsA[clusA %in% clustersA[-clustersA[j]],], xsB, x, ind_sam[c(clusA %in% clustersA[-clustersA[j]], rep(TRUE, nrow(ysB)))])[[2]][[l]][1,]
k <- k + 1
}
YcAMean <- matrix(colMeans(YcA), nclustersA, m, byrow = TRUE)
if (fcpA)
fA <- 1 - mean(probclustersA)
else
fA <- 1
YcstrataA[i,] <- (nclustersA - 1) / nclustersA * fA * colSums((YcA - YcAMean)^2)
}
vjA <- colSums(YcstrataA)
}else{
YcA <- matrix(0, nA, m)
for (i in 1:nA)
YcA[i,] <- MLSW(ysA[-i,], ysB, pik_A[-i], pik_B, pik_ab_B[-i], pik_ba_A, domains_A[-i], domains_B, xsA[-i,], xsB, x, ind_sam[-i])[[2]][[l]][1,]
YcAMean <- matrix(colMeans(YcA), nA, m, byrow = TRUE)
if (fcpA)
fA <- 1 - mean(pik_A)
else
fA <- 1
vjA <- ((nA - 1) / nA) * fA * colSums ((YcA - YcAMean)^2)
}
}
}
if (sdB == "str"){
strataB <- unique(sort(strB))
nhB <- table(strB)
nstrataB <- length(nhB)
YcstrataB <- matrix(0, nstrataB, m)
nhB <- c(0,nhB)
cnhB <- cumsum(nhB)
for (i in 1:nstrataB){
k <- 1
YcB <- matrix(0, nhB[i+1], m, byrow = TRUE)
for (j in (cnhB[i]+1):cnhB[i+1]){
YcB[k,] <- MLSW(ysA, ysB[-j,], pik_A, pik_B[-j], pik_ab_B, pik_ba_A[-j], domains_A, domains_B[-j], xsA, xsB[-j,], x, ind_sam[-(nA + j)])[[2]][[l]][1,]
k <- k + 1
}
YcBMean <- matrix(colMeans(YcB), nhB[i+1], m, byrow = TRUE)
if (fcpB)
fB <- 1 - mean(pik_B[strB == strataB[i]])
else
fB <- 1
YcstrataB[i,] <- (nhB[i+1] - 1) / nhB[i+1] * fB * colSums((YcB - YcBMean)^2)
}
vjB <- colSums(YcstrataB)
}
else{
if (sdB == "clu"){
clustersB <- unique(clusB)
probclustersB <- unique(data.frame(pik_B, clusB))[,1]
nclustersB <- length(clustersB)
if (nclustersB < 3)
stop("Number of clusters from frame B is less than 3. Variance cannot be computed.")
YcB <- matrix(0, nclustersB, m)
for (i in 1:nclustersB)
YcB[i,] <- MLSW(ysA, ysB[clusB %in% clustersB[-clustersB[i]],], pik_A, pik_B[clusB %in% clustersB[-clustersB[i]]], pik_ab_B, pik_ba_A[clusB %in% clustersB[-clustersB[i]]], domains_A, domains_B[clusB %in% clustersB[-clustersB[i]]], xsA, xsB[clusB %in% clustersB[-clustersB[i]],], x, ind_sam[c(rep(TRUE, nA), clusB %in% clustersB[-clustersB[i]])])[[2]][[l]][1,]
YcBMean <- matrix(colMeans(YcB), nclustersB, m, byrow = TRUE)
if (fcpB)
fB <- 1 - mean(probclustersB)
else
fB <- 1
vjB <- ((nclustersB - 1) / nclustersB) * fB * colSums ((YcB - YcBMean)^2)
}
else{
if (sdB == "strclu"){
strataB <- unique(sort(strB))
nstrataB <- length(strataB)
YcstrataB <- matrix(0, nstrataB, m)
for (i in 1:nstrataB){
clustersB <- unique(clusB[strB == strataB[i]])
probclustersB <- unique(data.frame(pik_B[strB == strataB[i]], clusA[strB == strataB[i]]))[,1]
nclustersB <- length(clustersB)
if (nclustersB < 3)
stop("Number of clusters in any stratum from frame B is less than 3. Variance cannot be computed.")
k <- 1
YcB <- matrix(0, nclustersB, m)
for (j in 1:nclustersB){
YcB[k,] <- MLSW(ysA, ysB[clusB %in% clustersB[-clustersB[j]],], pik_A, pik_B[clusB %in% clustersB[-clustersB[j]]], pik_ab_B, pik_ba_A[clusB %in% clustersB[-clustersB[j]]], domains_A, domains_B[clusB %in% clustersB[-clustersB[j]]], xsA, xsB[clusB %in% clustersB[-clustersB[j]],], x, ind_sam[c(rep(TRUE, nrow(ysA)), clusB %in% clustersB[-clustersB[j]])])[[2]][[l]][1,]
k <- k + 1
}
YcBMean <- matrix(colMeans(YcB), nclustersB, m, byrow = TRUE)
if (fcpB)
fB <- 1 - mean(probclustersB)
else
fB <- 1
YcstrataB[i,] <- (nclustersB - 1) / nclustersB * fB * colSums((YcB - YcBMean)^2)
}
vjB <- colSums(YcstrataB)
}
else{
YcB <- matrix(0, nB, m)
for (i in 1:nB)
YcB[i,] <- MLSW(ysA, ysB[-i,], pik_A, pik_B[-i], pik_ab_B, pik_ba_A[-i], domains_A, domains_B[-i], xsA, xsB[-i,], x, ind_sam[-(nA + i)])[[2]][[l]][1,]
YcBMean <- matrix(colMeans(YcB), nB, m, byrow = TRUE)
if (fcpB)
fB <- 1 - mean(pik_B)
else
fB <- 1
vjB <- ((nB - 1) / nB) * fB * colSums((YcB - YcBMean)^2)
}
}
}
VJack_Phat_MLSW <- vjA + vjB
mat[1,] <- estimation[[l]][1,]
mat[2,] <- estimation[[l]][1,] + qnorm(1 - (1 - conf_level) / 2) * sqrt(VJack_Phat_MLSW)
mat[3,] <- estimation[[l]][1,] - qnorm(1 - (1 - conf_level) / 2) * sqrt(VJack_Phat_MLSW)
mat[4,] <- estimation[[l]][2,]
mat[5,] <- estimation[[l]][2,] + qnorm(1 - (1 - conf_level) / 2) * sqrt(1/N^2 * VJack_Phat_MLSW)
mat[6,] <- estimation[[l]][2,] - qnorm(1 - (1 - conf_level) / 2) * sqrt(1/N^2 * VJack_Phat_MLSW)
results[[l]] <- mat
}
return(results)
} |
lav_mvnorm_missing_h1_estimate_moments <- function(Y = NULL,
Mp = NULL,
Yp = NULL,
wt = NULL,
Sinv.method = "eigen",
verbose = FALSE,
max.iter = 500L,
tol = 1e-05,
warn = FALSE) {
Y <- as.matrix(Y); P <- NCOL(Y)
if(!is.null(wt)) {
N <- sum(wt)
} else {
N <- NROW(Y)
}
if(is.null(Mp)) {
Mp <- lav_data_missing_patterns(Y)
}
if(is.null(Yp)) {
Yp <- lav_samplestats_missing_patterns(Y = Y, Mp = Mp, wt = wt)
}
if(is.null(max.iter)) {
max.iter <- 500L
}
if(is.null(tol)) {
tol <- 1e-05
}
if(is.null(warn)) {
warn <- FALSE
}
N.full <- N
if(length(Mp$empty.idx) > 0L) {
if(!is.null(wt)) {
N <- N - sum(wt[Mp$empty.idx])
} else {
N <- N - length(Mp$empty.idx)
}
}
if(verbose) {
cat("\n")
cat("lav_mvnorm_missing_h1_estimate_moments: start EM steps\n")
}
if(!is.null(wt)) {
tmp <- na.omit(cbind(wt, Y))
if(nrow(tmp) > 2L) {
Y.tmp <- tmp[,-1, drop = FALSE]
wt.tmp <- tmp[,1]
out <- stats::cov.wt(Y.tmp, wt = wt.tmp, method = "ML")
Mu0 <- out$center
var0 <- diag(out$cov)
} else {
Mu0 <- base::.colMeans(Y, m = N.full, n = P, na.rm = TRUE)
Yc <- t( t(Y) - Mu0 )
var0 <- base::.colMeans(Yc*Yc, m = N.full, n = P, na.rm = TRUE)
}
} else {
Mu0 <- base::.colMeans(Y, m = N.full, n = P, na.rm = TRUE)
Yc <- t( t(Y) - Mu0 )
var0 <- base::.colMeans(Yc*Yc, m = N.full, n = P, na.rm = TRUE)
}
bad.idx <- which(!is.finite(var0) | var0 == 0)
if(length(bad.idx) > 0L) {
var0[bad.idx] <- 1
}
bad.idx <- which(!is.finite(Mu0))
if(length(bad.idx) > 0L) {
}
Sigma0 <- diag(x = var0, nrow = P)
Mu <- Mu0; Sigma <- Sigma0
if(verbose) {
fx0 <- lav_mvnorm_missing_loglik_samplestats(Yp = Yp,
Mu = Mu, Sigma = Sigma,
log2pi = FALSE,
minus.two = TRUE)/N
cat(" EM iteration:", sprintf("%4d", 0),
" fx = ", sprintf("%15.10f", fx0),
"\n")
}
for(i in 1:max.iter) {
Estep <- lav_mvnorm_missing_estep(Y = Y, Mp = Mp, wt = wt,
Mu = Mu, Sigma = Sigma,
Sinv.method = Sinv.method)
T1 <- Estep$T1
T2 <- Estep$T2
Mu <- T1/N
Sigma <- T2/N - tcrossprod(Mu)
ev <- eigen(Sigma, symmetric = TRUE, only.values = TRUE)
evtol <- 1e-6
if(any(ev$values < evtol)) {
diag(Sigma) <- diag(Sigma) + max(diag(Sigma))*1e-08
}
DELTA <- max(abs(c(Mu, lav_matrix_vech(Sigma)) -
c(Mu0, lav_matrix_vech(Sigma0))))
if(verbose) {
fx <- lav_mvnorm_missing_loglik_samplestats(Yp = Yp,
Mu = Mu, Sigma = Sigma,
log2pi = FALSE,
minus.two = TRUE)/N
cat(" EM iteration:", sprintf("%4d", i),
" fx = ", sprintf("%15.10f", fx),
" delta par = ", sprintf("%9.8f", DELTA),
"\n")
}
if(DELTA < tol)
break
Mu0 <- Mu; Sigma0 <- Sigma
}
if(verbose) {
cat("\nSigma:\n"); print(Sigma)
cat("\nMu:\n"); print(Mu)
cat("\n")
}
if(!verbose) {
fx <- lav_mvnorm_missing_loglik_samplestats(Yp = Yp,
Mu = Mu, Sigma = Sigma,
log2pi = FALSE,
minus.two = TRUE)/N
}
if(warn && i == max.iter) {
txt <- c("Maximum number of iterations reached when ",
"computing the sample moments using EM; ",
"use the em.h1.iter.max= argument to increase the number of ",
"iterations")
warning(lav_txt2message(txt))
}
if(warn) {
ev <- eigen(Sigma, symmetric = TRUE, only.values = TRUE)$values
if(any(ev < 1e-05)) {
txt <- c("The smallest eigenvalue of the EM estimated ",
"variance-covariance matrix (Sigma) is smaller than ",
"1e-05; this may cause numerical instabilities; ",
"interpret the results with caution.")
warning(lav_txt2message(txt))
}
}
list(Sigma = Sigma, Mu = Mu, fx = fx)
}
lav_mvnorm_missing_h1_omega_sw <- function(Y = NULL,
Mp = NULL,
wt = NULL,
cluster.idx = NULL,
Yp = NULL,
Sinv.method = "eigen",
Mu = NULL,
Sigma = NULL,
x.idx = NULL,
Sigma.inv = NULL,
information = "observed") {
if(is.null(Mp)) {
Mp <- lav_data_missing_patterns(Y)
}
if(is.null(Yp) && (information == "observed" || is.null(Sigma))) {
Yp <- lav_samplestats_missing_patterns(Y = Y, Mp = Mp, wt = wt)
}
if(is.null(Sigma) || is.null(Mu)) {
out <- lav_mvnorm_missing_h1_estimate_moments(Y = Y, Mp = Mp, Yp = Yp)
Mu <- out$Mu
Sigma <- out$Sigma
}
info <- lav_mvnorm_missing_information_both(Y = Y, Mp = Mp, Mu = Mu,
wt = wt, cluster.idx = cluster.idx,
Sigma = Sigma, x.idx = x.idx, Sinv.method = Sinv.method,
Sigma.inv = Sigma.inv, information = information)
A <- info$Abeta
A.inv <- lav_matrix_symmetric_inverse(S = A, logdet = FALSE,
Sinv.method = Sinv.method)
B <- info$Bbeta
SW <- A.inv %*% B %*% A.inv
SW
} |
unloadNamespace("gam")
if (require("testthat") && require("ggeffects") && require("VGAM")) {
data("hunua")
m1 <- vgam(agaaus ~ vitluc + s(altitude, df = 2), binomialff, data = hunua)
test_that("ggpredict", {
p <- ggpredict(m1, "vitluc")
expect_equal(p$predicted[1], 0.2745789, tolerance = 1e-3)
})
} |
NULL
.sagemaker$add_association_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), DestinationArn = structure(logical(0), tags = list(type = "string")), AssociationType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$add_association_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), DestinationArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$add_tags_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ResourceArn = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$add_tags_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$associate_trial_component_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$associate_trial_component_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentArn = structure(logical(0), tags = list(type = "string")), TrialArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_action_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ActionName = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string")), SourceId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ActionType = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), Properties = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_action_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ActionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_algorithm_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AlgorithmName = structure(logical(0), tags = list(type = "string")), AlgorithmDescription = structure(logical(0), tags = list(type = "string")), TrainingSpecification = structure(list(TrainingImage = structure(logical(0), tags = list(type = "string")), TrainingImageDigest = structure(logical(0), tags = list(type = "string")), SupportedHyperParameters = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), Type = structure(logical(0), tags = list(type = "string")), Range = structure(list(IntegerParameterRangeSpecification = structure(list(MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ContinuousParameterRangeSpecification = structure(list(MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CategoricalParameterRangeSpecification = structure(list(Values = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), IsTunable = structure(logical(0), tags = list(type = "boolean")), IsRequired = structure(logical(0), tags = list(type = "boolean")), DefaultValue = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), SupportedTrainingInstanceTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportsDistributedTraining = structure(logical(0), tags = list(type = "boolean")), MetricDefinitions = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Regex = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), TrainingChannels = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), IsRequired = structure(logical(0), tags = list(type = "boolean")), SupportedContentTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedCompressionTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedInputModes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "list")), SupportedTuningJobObjectiveMetrics = structure(list(structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), InferenceSpecification = structure(list(Containers = structure(list(structure(list(ContainerHostname = structure(logical(0), tags = list(type = "string")), Image = structure(logical(0), tags = list(type = "string")), ImageDigest = structure(logical(0), tags = list(type = "string")), ModelDataUrl = structure(logical(0), tags = list(type = "string")), ProductId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), SupportedTransformInstanceTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedRealtimeInferenceInstanceTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedContentTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedResponseMIMETypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), ValidationSpecification = structure(list(ValidationRole = structure(logical(0), tags = list(type = "string")), ValidationProfiles = structure(list(structure(list(ProfileName = structure(logical(0), tags = list(type = "string")), TrainingJobDefinition = structure(list(TrainingInputMode = structure(logical(0), tags = list(type = "string")), HyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), InputDataConfig = structure(list(structure(list(ChannelName = structure(logical(0), tags = list(type = "string")), DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), AttributeNames = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), FileSystemDataSource = structure(list(FileSystemId = structure(logical(0), tags = list(type = "string")), FileSystemAccessMode = structure(logical(0), tags = list(type = "string")), FileSystemType = structure(logical(0), tags = list(type = "string")), DirectoryPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), RecordWrapperType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string")), ShuffleConfig = structure(list(Seed = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), OutputDataConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceConfig = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxWaitTimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure")), TransformJobDefinition = structure(list(MaxConcurrentTransforms = structure(logical(0), tags = list(type = "integer")), MaxPayloadInMB = structure(logical(0), tags = list(type = "integer")), BatchStrategy = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), TransformInput = structure(list(DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), SplitType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformOutput = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), Accept = structure(logical(0), tags = list(type = "string")), AssembleWith = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformResources = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), CertifyForMarketplace = structure(logical(0), tags = list(type = "boolean")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_algorithm_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AlgorithmArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_app_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainId = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), AppType = structure(logical(0), tags = list(type = "string")), AppName = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_app_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AppArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_app_image_config_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AppImageConfigName = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), KernelGatewayImageConfig = structure(list(KernelSpecs = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), FileSystemConfig = structure(list(MountPath = structure(logical(0), tags = list(type = "string")), DefaultUid = structure(logical(0), tags = list(box = TRUE, type = "integer")), DefaultGid = structure(logical(0), tags = list(box = TRUE, type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_app_image_config_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AppImageConfigArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_artifact_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ArtifactName = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), SourceTypes = structure(list(structure(list(SourceIdType = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ArtifactType = structure(logical(0), tags = list(type = "string")), Properties = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_artifact_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ArtifactArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_auto_ml_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AutoMLJobName = structure(logical(0), tags = list(type = "string")), InputDataConfig = structure(list(structure(list(DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), CompressionType = structure(logical(0), tags = list(type = "string")), TargetAttributeName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), OutputDataConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ProblemType = structure(logical(0), tags = list(type = "string")), AutoMLJobObjective = structure(list(MetricName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), AutoMLJobConfig = structure(list(CompletionCriteria = structure(list(MaxCandidates = structure(logical(0), tags = list(type = "integer")), MaxRuntimePerTrainingJobInSeconds = structure(logical(0), tags = list(type = "integer")), MaxAutoMLJobRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), SecurityConfig = structure(list(VolumeKmsKeyId = structure(logical(0), tags = list(type = "string")), EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), GenerateCandidateDefinitionsOnly = structure(logical(0), tags = list(type = "boolean")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_auto_ml_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AutoMLJobArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_code_repository_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CodeRepositoryName = structure(logical(0), tags = list(type = "string")), GitConfig = structure(list(RepositoryUrl = structure(logical(0), tags = list(type = "string")), Branch = structure(logical(0), tags = list(type = "string")), SecretArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_code_repository_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CodeRepositoryArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_compilation_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CompilationJobName = structure(logical(0), tags = list(type = "string")), RoleArn = structure(logical(0), tags = list(type = "string")), InputConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), DataInputConfig = structure(logical(0), tags = list(type = "string")), Framework = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), OutputConfig = structure(list(S3OutputLocation = structure(logical(0), tags = list(type = "string")), TargetDevice = structure(logical(0), tags = list(type = "string")), TargetPlatform = structure(list(Os = structure(logical(0), tags = list(type = "string")), Arch = structure(logical(0), tags = list(type = "string")), Accelerator = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CompilerOptions = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxWaitTimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_compilation_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CompilationJobArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_context_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ContextName = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string")), SourceId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ContextType = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), Properties = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_context_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ContextArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_data_quality_job_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionName = structure(logical(0), tags = list(type = "string")), DataQualityBaselineConfig = structure(list(BaseliningJobName = structure(logical(0), tags = list(type = "string")), ConstraintsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StatisticsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), DataQualityAppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ContainerEntrypoint = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), ContainerArguments = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), RecordPreprocessorSourceUri = structure(logical(0), tags = list(type = "string")), PostAnalyticsProcessorSourceUri = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure")), DataQualityJobInput = structure(list(EndpointInput = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), FeaturesAttribute = structure(logical(0), tags = list(type = "string")), InferenceAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityThresholdAttribute = structure(logical(0), tags = list(type = "double")), StartTimeOffset = structure(logical(0), tags = list(type = "string")), EndTimeOffset = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), DataQualityJobOutputConfig = structure(list(MonitoringOutputs = structure(list(structure(list(S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JobResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_data_quality_job_definition_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_device_fleet_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceFleetName = structure(logical(0), tags = list(type = "string")), RoleArn = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), OutputConfig = structure(list(S3OutputLocation = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_device_fleet_output <- function(...) {
list()
}
.sagemaker$create_domain_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainName = structure(logical(0), tags = list(type = "string")), AuthMode = structure(logical(0), tags = list(type = "string")), DefaultUserSettings = structure(list(ExecutionRole = structure(logical(0), tags = list(type = "string")), SecurityGroups = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SharingSettings = structure(list(NotebookOutputOption = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), S3KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JupyterServerAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), KernelGatewayAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CustomImages = structure(list(structure(list(ImageName = structure(logical(0), tags = list(type = "string")), ImageVersionNumber = structure(logical(0), tags = list(box = TRUE, type = "integer")), AppImageConfigName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), TensorBoardAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure")), SubnetIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), VpcId = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), AppNetworkAccessType = structure(logical(0), tags = list(type = "string")), HomeEfsFileSystemKmsKeyId = structure(logical(0), tags = list(deprecated = TRUE, deprecatedMessage = "This property is deprecated, use KmsKeyId instead.", type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_domain_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainArn = structure(logical(0), tags = list(type = "string")), Url = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_edge_packaging_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EdgePackagingJobName = structure(logical(0), tags = list(type = "string")), CompilationJobName = structure(logical(0), tags = list(type = "string")), ModelName = structure(logical(0), tags = list(type = "string")), ModelVersion = structure(logical(0), tags = list(type = "string")), RoleArn = structure(logical(0), tags = list(type = "string")), OutputConfig = structure(list(S3OutputLocation = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceKey = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_edge_packaging_job_output <- function(...) {
list()
}
.sagemaker$create_endpoint_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), EndpointConfigName = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_endpoint_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_endpoint_config_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointConfigName = structure(logical(0), tags = list(type = "string")), ProductionVariants = structure(list(structure(list(VariantName = structure(logical(0), tags = list(type = "string")), ModelName = structure(logical(0), tags = list(type = "string")), InitialInstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), InitialVariantWeight = structure(logical(0), tags = list(type = "float")), AcceleratorType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), DataCaptureConfig = structure(list(EnableCapture = structure(logical(0), tags = list(type = "boolean")), InitialSamplingPercentage = structure(logical(0), tags = list(type = "integer")), DestinationS3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string")), CaptureOptions = structure(list(structure(list(CaptureMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), CaptureContentTypeHeader = structure(list(CsvContentTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), JsonContentTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_endpoint_config_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointConfigArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_experiment_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_experiment_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ExperimentArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_feature_group_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(FeatureGroupName = structure(logical(0), tags = list(type = "string")), RecordIdentifierFeatureName = structure(logical(0), tags = list(type = "string")), EventTimeFeatureName = structure(logical(0), tags = list(type = "string")), FeatureDefinitions = structure(list(structure(list(FeatureName = structure(logical(0), tags = list(type = "string")), FeatureType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), OnlineStoreConfig = structure(list(SecurityConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), EnableOnlineStore = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure")), OfflineStoreConfig = structure(list(S3StorageConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DisableGlueTableCreation = structure(logical(0), tags = list(type = "boolean")), DataCatalogConfig = structure(list(TableName = structure(logical(0), tags = list(type = "string")), Catalog = structure(logical(0), tags = list(type = "string")), Database = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_feature_group_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(FeatureGroupArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_flow_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(FlowDefinitionName = structure(logical(0), tags = list(type = "string")), HumanLoopRequestSource = structure(list(AwsManagedHumanLoopRequestSource = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), HumanLoopActivationConfig = structure(list(HumanLoopActivationConditionsConfig = structure(list(HumanLoopActivationConditions = structure(logical(0), tags = list(jsonvalue = TRUE, type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), HumanLoopConfig = structure(list(WorkteamArn = structure(logical(0), tags = list(type = "string")), HumanTaskUiArn = structure(logical(0), tags = list(type = "string")), TaskTitle = structure(logical(0), tags = list(type = "string")), TaskDescription = structure(logical(0), tags = list(type = "string")), TaskCount = structure(logical(0), tags = list(type = "integer")), TaskAvailabilityLifetimeInSeconds = structure(logical(0), tags = list(type = "integer")), TaskTimeLimitInSeconds = structure(logical(0), tags = list(type = "integer")), TaskKeywords = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), PublicWorkforceTaskPrice = structure(list(AmountInUsd = structure(list(Dollars = structure(logical(0), tags = list(type = "integer")), Cents = structure(logical(0), tags = list(type = "integer")), TenthFractionsOfACent = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure")), OutputConfig = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_flow_definition_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(FlowDefinitionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_human_task_ui_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HumanTaskUiName = structure(logical(0), tags = list(type = "string")), UiTemplate = structure(list(Content = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_human_task_ui_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HumanTaskUiArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_hyper_parameter_tuning_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HyperParameterTuningJobName = structure(logical(0), tags = list(type = "string")), HyperParameterTuningJobConfig = structure(list(Strategy = structure(logical(0), tags = list(type = "string")), HyperParameterTuningJobObjective = structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceLimits = structure(list(MaxNumberOfTrainingJobs = structure(logical(0), tags = list(type = "integer")), MaxParallelTrainingJobs = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), ParameterRanges = structure(list(IntegerParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string")), ScalingType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ContinuousParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string")), ScalingType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), CategoricalParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Values = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), TrainingJobEarlyStoppingType = structure(logical(0), tags = list(type = "string")), TuningJobCompletionCriteria = structure(list(TargetObjectiveMetricValue = structure(logical(0), tags = list(type = "float"))), tags = list(type = "structure"))), tags = list(type = "structure")), TrainingJobDefinition = structure(list(DefinitionName = structure(logical(0), tags = list(type = "string")), TuningObjective = structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), HyperParameterRanges = structure(list(IntegerParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string")), ScalingType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ContinuousParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string")), ScalingType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), CategoricalParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Values = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), StaticHyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), AlgorithmSpecification = structure(list(TrainingImage = structure(logical(0), tags = list(type = "string")), TrainingInputMode = structure(logical(0), tags = list(type = "string")), AlgorithmName = structure(logical(0), tags = list(type = "string")), MetricDefinitions = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Regex = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), InputDataConfig = structure(list(structure(list(ChannelName = structure(logical(0), tags = list(type = "string")), DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), AttributeNames = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), FileSystemDataSource = structure(list(FileSystemId = structure(logical(0), tags = list(type = "string")), FileSystemAccessMode = structure(logical(0), tags = list(type = "string")), FileSystemType = structure(logical(0), tags = list(type = "string")), DirectoryPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), RecordWrapperType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string")), ShuffleConfig = structure(list(Seed = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), OutputDataConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceConfig = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxWaitTimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableManagedSpotTraining = structure(logical(0), tags = list(type = "boolean")), CheckpointConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), TrainingJobDefinitions = structure(list(structure(list(DefinitionName = structure(logical(0), tags = list(type = "string")), TuningObjective = structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), HyperParameterRanges = structure(list(IntegerParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string")), ScalingType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ContinuousParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string")), ScalingType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), CategoricalParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Values = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), StaticHyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), AlgorithmSpecification = structure(list(TrainingImage = structure(logical(0), tags = list(type = "string")), TrainingInputMode = structure(logical(0), tags = list(type = "string")), AlgorithmName = structure(logical(0), tags = list(type = "string")), MetricDefinitions = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Regex = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), InputDataConfig = structure(list(structure(list(ChannelName = structure(logical(0), tags = list(type = "string")), DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), AttributeNames = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), FileSystemDataSource = structure(list(FileSystemId = structure(logical(0), tags = list(type = "string")), FileSystemAccessMode = structure(logical(0), tags = list(type = "string")), FileSystemType = structure(logical(0), tags = list(type = "string")), DirectoryPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), RecordWrapperType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string")), ShuffleConfig = structure(list(Seed = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), OutputDataConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceConfig = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxWaitTimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableManagedSpotTraining = structure(logical(0), tags = list(type = "boolean")), CheckpointConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), WarmStartConfig = structure(list(ParentHyperParameterTuningJobs = structure(list(structure(list(HyperParameterTuningJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), WarmStartType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_hyper_parameter_tuning_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HyperParameterTuningJobArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_image_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Description = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), ImageName = structure(logical(0), tags = list(type = "string")), RoleArn = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_image_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ImageArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_image_version_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(BaseImage = structure(logical(0), tags = list(type = "string")), ClientToken = structure(logical(0), tags = list(idempotencyToken = TRUE, type = "string")), ImageName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_image_version_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ImageVersionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_labeling_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(LabelingJobName = structure(logical(0), tags = list(type = "string")), LabelAttributeName = structure(logical(0), tags = list(type = "string")), InputConfig = structure(list(DataSource = structure(list(S3DataSource = structure(list(ManifestS3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), SnsDataSource = structure(list(SnsTopicArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), DataAttributes = structure(list(ContentClassifiers = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), OutputConfig = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string")), SnsTopicArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), LabelCategoryConfigS3Uri = structure(logical(0), tags = list(type = "string")), StoppingConditions = structure(list(MaxHumanLabeledObjectCount = structure(logical(0), tags = list(type = "integer")), MaxPercentageOfInputDatasetLabeled = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), LabelingJobAlgorithmsConfig = structure(list(LabelingJobAlgorithmSpecificationArn = structure(logical(0), tags = list(type = "string")), InitialActiveLearningModelArn = structure(logical(0), tags = list(type = "string")), LabelingJobResourceConfig = structure(list(VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), HumanTaskConfig = structure(list(WorkteamArn = structure(logical(0), tags = list(type = "string")), UiConfig = structure(list(UiTemplateS3Uri = structure(logical(0), tags = list(type = "string")), HumanTaskUiArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), PreHumanTaskLambdaArn = structure(logical(0), tags = list(type = "string")), TaskKeywords = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), TaskTitle = structure(logical(0), tags = list(type = "string")), TaskDescription = structure(logical(0), tags = list(type = "string")), NumberOfHumanWorkersPerDataObject = structure(logical(0), tags = list(type = "integer")), TaskTimeLimitInSeconds = structure(logical(0), tags = list(type = "integer")), TaskAvailabilityLifetimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxConcurrentTaskCount = structure(logical(0), tags = list(type = "integer")), AnnotationConsolidationConfig = structure(list(AnnotationConsolidationLambdaArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), PublicWorkforceTaskPrice = structure(list(AmountInUsd = structure(list(Dollars = structure(logical(0), tags = list(type = "integer")), Cents = structure(logical(0), tags = list(type = "integer")), TenthFractionsOfACent = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_labeling_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(LabelingJobArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_model_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelName = structure(logical(0), tags = list(type = "string")), PrimaryContainer = structure(list(ContainerHostname = structure(logical(0), tags = list(type = "string")), Image = structure(logical(0), tags = list(type = "string")), ImageConfig = structure(list(RepositoryAccessMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Mode = structure(logical(0), tags = list(type = "string")), ModelDataUrl = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), ModelPackageName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Containers = structure(list(structure(list(ContainerHostname = structure(logical(0), tags = list(type = "string")), Image = structure(logical(0), tags = list(type = "string")), ImageConfig = structure(list(RepositoryAccessMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Mode = structure(logical(0), tags = list(type = "string")), ModelDataUrl = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), ModelPackageName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ExecutionRoleArn = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_model_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_model_bias_job_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionName = structure(logical(0), tags = list(type = "string")), ModelBiasBaselineConfig = structure(list(BaseliningJobName = structure(logical(0), tags = list(type = "string")), ConstraintsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelBiasAppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ConfigUri = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure")), ModelBiasJobInput = structure(list(EndpointInput = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), FeaturesAttribute = structure(logical(0), tags = list(type = "string")), InferenceAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityThresholdAttribute = structure(logical(0), tags = list(type = "double")), StartTimeOffset = structure(logical(0), tags = list(type = "string")), EndTimeOffset = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), GroundTruthS3Input = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelBiasJobOutputConfig = structure(list(MonitoringOutputs = structure(list(structure(list(S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JobResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_model_bias_job_definition_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_model_explainability_job_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionName = structure(logical(0), tags = list(type = "string")), ModelExplainabilityBaselineConfig = structure(list(BaseliningJobName = structure(logical(0), tags = list(type = "string")), ConstraintsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelExplainabilityAppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ConfigUri = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure")), ModelExplainabilityJobInput = structure(list(EndpointInput = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), FeaturesAttribute = structure(logical(0), tags = list(type = "string")), InferenceAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityThresholdAttribute = structure(logical(0), tags = list(type = "double")), StartTimeOffset = structure(logical(0), tags = list(type = "string")), EndTimeOffset = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelExplainabilityJobOutputConfig = structure(list(MonitoringOutputs = structure(list(structure(list(S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JobResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_model_explainability_job_definition_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_model_package_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageName = structure(logical(0), tags = list(type = "string")), ModelPackageGroupName = structure(logical(0), tags = list(type = "string")), ModelPackageDescription = structure(logical(0), tags = list(type = "string")), InferenceSpecification = structure(list(Containers = structure(list(structure(list(ContainerHostname = structure(logical(0), tags = list(type = "string")), Image = structure(logical(0), tags = list(type = "string")), ImageDigest = structure(logical(0), tags = list(type = "string")), ModelDataUrl = structure(logical(0), tags = list(type = "string")), ProductId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), SupportedTransformInstanceTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedRealtimeInferenceInstanceTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedContentTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedResponseMIMETypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), ValidationSpecification = structure(list(ValidationRole = structure(logical(0), tags = list(type = "string")), ValidationProfiles = structure(list(structure(list(ProfileName = structure(logical(0), tags = list(type = "string")), TransformJobDefinition = structure(list(MaxConcurrentTransforms = structure(logical(0), tags = list(type = "integer")), MaxPayloadInMB = structure(logical(0), tags = list(type = "integer")), BatchStrategy = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), TransformInput = structure(list(DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), SplitType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformOutput = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), Accept = structure(logical(0), tags = list(type = "string")), AssembleWith = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformResources = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), SourceAlgorithmSpecification = structure(list(SourceAlgorithms = structure(list(structure(list(ModelDataUrl = structure(logical(0), tags = list(type = "string")), AlgorithmName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), CertifyForMarketplace = structure(logical(0), tags = list(type = "boolean")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ModelApprovalStatus = structure(logical(0), tags = list(type = "string")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ModelMetrics = structure(list(ModelQuality = structure(list(Statistics = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Constraints = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelDataQuality = structure(list(Statistics = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Constraints = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), Bias = structure(list(Report = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), Explainability = structure(list(Report = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure")), ClientToken = structure(logical(0), tags = list(idempotencyToken = TRUE, type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_model_package_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_model_package_group_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageGroupName = structure(logical(0), tags = list(type = "string")), ModelPackageGroupDescription = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_model_package_group_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageGroupArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_model_quality_job_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionName = structure(logical(0), tags = list(type = "string")), ModelQualityBaselineConfig = structure(list(BaseliningJobName = structure(logical(0), tags = list(type = "string")), ConstraintsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelQualityAppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ContainerEntrypoint = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), ContainerArguments = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), RecordPreprocessorSourceUri = structure(logical(0), tags = list(type = "string")), PostAnalyticsProcessorSourceUri = structure(logical(0), tags = list(type = "string")), ProblemType = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure")), ModelQualityJobInput = structure(list(EndpointInput = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), FeaturesAttribute = structure(logical(0), tags = list(type = "string")), InferenceAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityThresholdAttribute = structure(logical(0), tags = list(type = "double")), StartTimeOffset = structure(logical(0), tags = list(type = "string")), EndTimeOffset = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), GroundTruthS3Input = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelQualityJobOutputConfig = structure(list(MonitoringOutputs = structure(list(structure(list(S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JobResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_model_quality_job_definition_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_monitoring_schedule_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MonitoringScheduleName = structure(logical(0), tags = list(type = "string")), MonitoringScheduleConfig = structure(list(ScheduleConfig = structure(list(ScheduleExpression = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MonitoringJobDefinition = structure(list(BaselineConfig = structure(list(BaseliningJobName = structure(logical(0), tags = list(type = "string")), ConstraintsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StatisticsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), MonitoringInputs = structure(list(structure(list(EndpointInput = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), FeaturesAttribute = structure(logical(0), tags = list(type = "string")), InferenceAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityThresholdAttribute = structure(logical(0), tags = list(type = "double")), StartTimeOffset = structure(logical(0), tags = list(type = "string")), EndTimeOffset = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), MonitoringOutputConfig = structure(list(MonitoringOutputs = structure(list(structure(list(S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MonitoringResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), MonitoringAppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ContainerEntrypoint = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), ContainerArguments = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), RecordPreprocessorSourceUri = structure(logical(0), tags = list(type = "string")), PostAnalyticsProcessorSourceUri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_monitoring_schedule_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MonitoringScheduleArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_notebook_instance_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceName = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string")), SubnetId = structure(logical(0), tags = list(type = "string")), SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), RoleArn = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), LifecycleConfigName = structure(logical(0), tags = list(type = "string")), DirectInternetAccess = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), AcceleratorTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), DefaultCodeRepository = structure(logical(0), tags = list(type = "string")), AdditionalCodeRepositories = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), RootAccess = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_notebook_instance_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_notebook_instance_lifecycle_config_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceLifecycleConfigName = structure(logical(0), tags = list(type = "string")), OnCreate = structure(list(structure(list(Content = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), OnStart = structure(list(structure(list(Content = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_notebook_instance_lifecycle_config_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceLifecycleConfigArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_pipeline_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineName = structure(logical(0), tags = list(type = "string")), PipelineDisplayName = structure(logical(0), tags = list(type = "string")), PipelineDefinition = structure(logical(0), tags = list(type = "string")), PipelineDescription = structure(logical(0), tags = list(type = "string")), ClientRequestToken = structure(logical(0), tags = list(idempotencyToken = TRUE, type = "string")), RoleArn = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_pipeline_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_presigned_domain_url_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainId = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), SessionExpirationDurationInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_presigned_domain_url_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AuthorizedUrl = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_presigned_notebook_instance_url_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceName = structure(logical(0), tags = list(type = "string")), SessionExpirationDurationInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_presigned_notebook_instance_url_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AuthorizedUrl = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_processing_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ProcessingInputs = structure(list(structure(list(InputName = structure(logical(0), tags = list(type = "string")), AppManaged = structure(logical(0), tags = list(type = "boolean")), S3Input = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3DataType = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), S3CompressionType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DatasetDefinition = structure(list(AthenaDatasetDefinition = structure(list(Catalog = structure(logical(0), tags = list(type = "string")), Database = structure(logical(0), tags = list(type = "string")), QueryString = structure(logical(0), tags = list(type = "string")), WorkGroup = structure(logical(0), tags = list(type = "string")), OutputS3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string")), OutputFormat = structure(logical(0), tags = list(type = "string")), OutputCompression = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), RedshiftDatasetDefinition = structure(list(ClusterId = structure(logical(0), tags = list(type = "string")), Database = structure(logical(0), tags = list(type = "string")), DbUser = structure(logical(0), tags = list(type = "string")), QueryString = structure(logical(0), tags = list(type = "string")), ClusterRoleArn = structure(logical(0), tags = list(type = "string")), OutputS3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string")), OutputFormat = structure(logical(0), tags = list(type = "string")), OutputCompression = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LocalPath = structure(logical(0), tags = list(type = "string")), DataDistributionType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), ProcessingOutputConfig = structure(list(Outputs = structure(list(structure(list(OutputName = structure(logical(0), tags = list(type = "string")), S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), FeatureStoreOutput = structure(list(FeatureGroupName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), AppManaged = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ProcessingJobName = structure(logical(0), tags = list(type = "string")), ProcessingResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), AppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ContainerEntrypoint = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), ContainerArguments = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ExperimentConfig = structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string")), TrialComponentDisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_processing_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ProcessingJobArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_project_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ProjectName = structure(logical(0), tags = list(type = "string")), ProjectDescription = structure(logical(0), tags = list(type = "string")), ServiceCatalogProvisioningDetails = structure(list(ProductId = structure(logical(0), tags = list(type = "string")), ProvisioningArtifactId = structure(logical(0), tags = list(type = "string")), PathId = structure(logical(0), tags = list(type = "string")), ProvisioningParameters = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_project_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ProjectArn = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_training_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrainingJobName = structure(logical(0), tags = list(type = "string")), HyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), AlgorithmSpecification = structure(list(TrainingImage = structure(logical(0), tags = list(type = "string")), AlgorithmName = structure(logical(0), tags = list(type = "string")), TrainingInputMode = structure(logical(0), tags = list(type = "string")), MetricDefinitions = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Regex = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), EnableSageMakerMetricsTimeSeries = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), InputDataConfig = structure(list(structure(list(ChannelName = structure(logical(0), tags = list(type = "string")), DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), AttributeNames = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), FileSystemDataSource = structure(list(FileSystemId = structure(logical(0), tags = list(type = "string")), FileSystemAccessMode = structure(logical(0), tags = list(type = "string")), FileSystemType = structure(logical(0), tags = list(type = "string")), DirectoryPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), RecordWrapperType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string")), ShuffleConfig = structure(list(Seed = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), OutputDataConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceConfig = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxWaitTimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableManagedSpotTraining = structure(logical(0), tags = list(type = "boolean")), CheckpointConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DebugHookConfig = structure(list(LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), HookParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), CollectionConfigurations = structure(list(structure(list(CollectionName = structure(logical(0), tags = list(type = "string")), CollectionParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), DebugRuleConfigurations = structure(list(structure(list(RuleConfigurationName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), RuleEvaluatorImage = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), RuleParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list")), TensorBoardOutputConfig = structure(list(LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ExperimentConfig = structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string")), TrialComponentDisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ProfilerConfig = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), ProfilingIntervalInMilliseconds = structure(logical(0), tags = list(type = "long")), ProfilingParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure")), ProfilerRuleConfigurations = structure(list(structure(list(RuleConfigurationName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), RuleEvaluatorImage = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), RuleParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_training_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrainingJobArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_transform_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TransformJobName = structure(logical(0), tags = list(type = "string")), ModelName = structure(logical(0), tags = list(type = "string")), MaxConcurrentTransforms = structure(logical(0), tags = list(type = "integer")), ModelClientConfig = structure(list(InvocationsTimeoutInSeconds = structure(logical(0), tags = list(type = "integer")), InvocationsMaxRetries = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), MaxPayloadInMB = structure(logical(0), tags = list(type = "integer")), BatchStrategy = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), TransformInput = structure(list(DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), SplitType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformOutput = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), Accept = structure(logical(0), tags = list(type = "string")), AssembleWith = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformResources = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DataProcessing = structure(list(InputFilter = structure(logical(0), tags = list(type = "string")), OutputFilter = structure(logical(0), tags = list(type = "string")), JoinSource = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ExperimentConfig = structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string")), TrialComponentDisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_transform_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TransformJobArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_trial_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialName = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), ExperimentName = structure(logical(0), tags = list(type = "string")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_trial_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_trial_component_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentName = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), Status = structure(list(PrimaryStatus = structure(logical(0), tags = list(type = "string")), Message = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StartTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), Parameters = structure(list(structure(list(StringValue = structure(logical(0), tags = list(type = "string")), NumberValue = structure(logical(0), tags = list(type = "double"))), tags = list(type = "structure"))), tags = list(type = "map")), InputArtifacts = structure(list(structure(list(MediaType = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "map")), OutputArtifacts = structure(list(structure(list(MediaType = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "map")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_trial_component_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_user_profile_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainId = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), SingleSignOnUserIdentifier = structure(logical(0), tags = list(type = "string")), SingleSignOnUserValue = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), UserSettings = structure(list(ExecutionRole = structure(logical(0), tags = list(type = "string")), SecurityGroups = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SharingSettings = structure(list(NotebookOutputOption = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), S3KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JupyterServerAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), KernelGatewayAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CustomImages = structure(list(structure(list(ImageName = structure(logical(0), tags = list(type = "string")), ImageVersionNumber = structure(logical(0), tags = list(box = TRUE, type = "integer")), AppImageConfigName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), TensorBoardAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_user_profile_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_workforce_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CognitoConfig = structure(list(UserPool = structure(logical(0), tags = list(type = "string")), ClientId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), OidcConfig = structure(list(ClientId = structure(logical(0), tags = list(type = "string")), ClientSecret = structure(logical(0), tags = list(type = "string", sensitive = TRUE)), Issuer = structure(logical(0), tags = list(type = "string")), AuthorizationEndpoint = structure(logical(0), tags = list(type = "string")), TokenEndpoint = structure(logical(0), tags = list(type = "string")), UserInfoEndpoint = structure(logical(0), tags = list(type = "string")), LogoutEndpoint = structure(logical(0), tags = list(type = "string")), JwksUri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), SourceIpConfig = structure(list(Cidrs = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), WorkforceName = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_workforce_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(WorkforceArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_workteam_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(WorkteamName = structure(logical(0), tags = list(type = "string")), WorkforceName = structure(logical(0), tags = list(type = "string")), MemberDefinitions = structure(list(structure(list(CognitoMemberDefinition = structure(list(UserPool = structure(logical(0), tags = list(type = "string")), UserGroup = structure(logical(0), tags = list(type = "string")), ClientId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), OidcMemberDefinition = structure(list(Groups = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), Description = structure(logical(0), tags = list(type = "string")), NotificationConfiguration = structure(list(NotificationTopicArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$create_workteam_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(WorkteamArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_action_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ActionName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_action_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ActionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_algorithm_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AlgorithmName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_algorithm_output <- function(...) {
list()
}
.sagemaker$delete_app_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainId = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), AppType = structure(logical(0), tags = list(type = "string")), AppName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_app_output <- function(...) {
list()
}
.sagemaker$delete_app_image_config_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AppImageConfigName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_app_image_config_output <- function(...) {
list()
}
.sagemaker$delete_artifact_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ArtifactArn = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), SourceTypes = structure(list(structure(list(SourceIdType = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_artifact_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ArtifactArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_association_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), DestinationArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_association_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), DestinationArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_code_repository_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CodeRepositoryName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_code_repository_output <- function(...) {
list()
}
.sagemaker$delete_context_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ContextName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_context_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ContextArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_data_quality_job_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_data_quality_job_definition_output <- function(...) {
list()
}
.sagemaker$delete_device_fleet_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceFleetName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_device_fleet_output <- function(...) {
list()
}
.sagemaker$delete_domain_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainId = structure(logical(0), tags = list(type = "string")), RetentionPolicy = structure(list(HomeEfsFileSystem = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_domain_output <- function(...) {
list()
}
.sagemaker$delete_endpoint_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_endpoint_output <- function(...) {
list()
}
.sagemaker$delete_endpoint_config_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointConfigName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_endpoint_config_output <- function(...) {
list()
}
.sagemaker$delete_experiment_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ExperimentName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_experiment_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ExperimentArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_feature_group_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(FeatureGroupName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_feature_group_output <- function(...) {
list()
}
.sagemaker$delete_flow_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(FlowDefinitionName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_flow_definition_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_human_task_ui_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HumanTaskUiName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_human_task_ui_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_image_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ImageName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_image_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_image_version_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ImageName = structure(logical(0), tags = list(type = "string")), Version = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_image_version_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_model_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_model_output <- function(...) {
list()
}
.sagemaker$delete_model_bias_job_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_model_bias_job_definition_output <- function(...) {
list()
}
.sagemaker$delete_model_explainability_job_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_model_explainability_job_definition_output <- function(...) {
list()
}
.sagemaker$delete_model_package_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_model_package_output <- function(...) {
list()
}
.sagemaker$delete_model_package_group_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageGroupName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_model_package_group_output <- function(...) {
list()
}
.sagemaker$delete_model_package_group_policy_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageGroupName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_model_package_group_policy_output <- function(...) {
list()
}
.sagemaker$delete_model_quality_job_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_model_quality_job_definition_output <- function(...) {
list()
}
.sagemaker$delete_monitoring_schedule_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MonitoringScheduleName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_monitoring_schedule_output <- function(...) {
list()
}
.sagemaker$delete_notebook_instance_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_notebook_instance_output <- function(...) {
list()
}
.sagemaker$delete_notebook_instance_lifecycle_config_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceLifecycleConfigName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_notebook_instance_lifecycle_config_output <- function(...) {
list()
}
.sagemaker$delete_pipeline_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineName = structure(logical(0), tags = list(type = "string")), ClientRequestToken = structure(logical(0), tags = list(idempotencyToken = TRUE, type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_pipeline_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_project_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ProjectName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_project_output <- function(...) {
list()
}
.sagemaker$delete_tags_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ResourceArn = structure(logical(0), tags = list(type = "string")), TagKeys = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_tags_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_trial_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_trial_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_trial_component_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_trial_component_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_user_profile_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainId = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_user_profile_output <- function(...) {
list()
}
.sagemaker$delete_workforce_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(WorkforceName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_workforce_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_workteam_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(WorkteamName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$delete_workteam_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Success = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$deregister_devices_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceFleetName = structure(logical(0), tags = list(type = "string")), DeviceNames = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$deregister_devices_output <- function(...) {
list()
}
.sagemaker$describe_action_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ActionName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_action_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ActionName = structure(logical(0), tags = list(type = "string")), ActionArn = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string")), SourceId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ActionType = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), Properties = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_algorithm_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AlgorithmName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_algorithm_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AlgorithmName = structure(logical(0), tags = list(type = "string")), AlgorithmArn = structure(logical(0), tags = list(type = "string")), AlgorithmDescription = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), TrainingSpecification = structure(list(TrainingImage = structure(logical(0), tags = list(type = "string")), TrainingImageDigest = structure(logical(0), tags = list(type = "string")), SupportedHyperParameters = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), Type = structure(logical(0), tags = list(type = "string")), Range = structure(list(IntegerParameterRangeSpecification = structure(list(MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ContinuousParameterRangeSpecification = structure(list(MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CategoricalParameterRangeSpecification = structure(list(Values = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), IsTunable = structure(logical(0), tags = list(type = "boolean")), IsRequired = structure(logical(0), tags = list(type = "boolean")), DefaultValue = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), SupportedTrainingInstanceTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportsDistributedTraining = structure(logical(0), tags = list(type = "boolean")), MetricDefinitions = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Regex = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), TrainingChannels = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), IsRequired = structure(logical(0), tags = list(type = "boolean")), SupportedContentTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedCompressionTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedInputModes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "list")), SupportedTuningJobObjectiveMetrics = structure(list(structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), InferenceSpecification = structure(list(Containers = structure(list(structure(list(ContainerHostname = structure(logical(0), tags = list(type = "string")), Image = structure(logical(0), tags = list(type = "string")), ImageDigest = structure(logical(0), tags = list(type = "string")), ModelDataUrl = structure(logical(0), tags = list(type = "string")), ProductId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), SupportedTransformInstanceTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedRealtimeInferenceInstanceTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedContentTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedResponseMIMETypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), ValidationSpecification = structure(list(ValidationRole = structure(logical(0), tags = list(type = "string")), ValidationProfiles = structure(list(structure(list(ProfileName = structure(logical(0), tags = list(type = "string")), TrainingJobDefinition = structure(list(TrainingInputMode = structure(logical(0), tags = list(type = "string")), HyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), InputDataConfig = structure(list(structure(list(ChannelName = structure(logical(0), tags = list(type = "string")), DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), AttributeNames = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), FileSystemDataSource = structure(list(FileSystemId = structure(logical(0), tags = list(type = "string")), FileSystemAccessMode = structure(logical(0), tags = list(type = "string")), FileSystemType = structure(logical(0), tags = list(type = "string")), DirectoryPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), RecordWrapperType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string")), ShuffleConfig = structure(list(Seed = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), OutputDataConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceConfig = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxWaitTimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure")), TransformJobDefinition = structure(list(MaxConcurrentTransforms = structure(logical(0), tags = list(type = "integer")), MaxPayloadInMB = structure(logical(0), tags = list(type = "integer")), BatchStrategy = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), TransformInput = structure(list(DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), SplitType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformOutput = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), Accept = structure(logical(0), tags = list(type = "string")), AssembleWith = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformResources = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), AlgorithmStatus = structure(logical(0), tags = list(type = "string")), AlgorithmStatusDetails = structure(list(ValidationStatuses = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ImageScanStatuses = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ProductId = structure(logical(0), tags = list(type = "string")), CertifyForMarketplace = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_app_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainId = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), AppType = structure(logical(0), tags = list(type = "string")), AppName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_app_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AppArn = structure(logical(0), tags = list(type = "string")), AppType = structure(logical(0), tags = list(type = "string")), AppName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), LastHealthCheckTimestamp = structure(logical(0), tags = list(type = "timestamp")), LastUserActivityTimestamp = structure(logical(0), tags = list(type = "timestamp")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), FailureReason = structure(logical(0), tags = list(type = "string")), ResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_app_image_config_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AppImageConfigName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_app_image_config_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AppImageConfigArn = structure(logical(0), tags = list(type = "string")), AppImageConfigName = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), KernelGatewayImageConfig = structure(list(KernelSpecs = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), FileSystemConfig = structure(list(MountPath = structure(logical(0), tags = list(type = "string")), DefaultUid = structure(logical(0), tags = list(box = TRUE, type = "integer")), DefaultGid = structure(logical(0), tags = list(box = TRUE, type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_artifact_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ArtifactArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_artifact_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ArtifactName = structure(logical(0), tags = list(type = "string")), ArtifactArn = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), SourceTypes = structure(list(structure(list(SourceIdType = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ArtifactType = structure(logical(0), tags = list(type = "string")), Properties = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_auto_ml_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AutoMLJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_auto_ml_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AutoMLJobName = structure(logical(0), tags = list(type = "string")), AutoMLJobArn = structure(logical(0), tags = list(type = "string")), InputDataConfig = structure(list(structure(list(DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), CompressionType = structure(logical(0), tags = list(type = "string")), TargetAttributeName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), OutputDataConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), AutoMLJobObjective = structure(list(MetricName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ProblemType = structure(logical(0), tags = list(type = "string")), AutoMLJobConfig = structure(list(CompletionCriteria = structure(list(MaxCandidates = structure(logical(0), tags = list(type = "integer")), MaxRuntimePerTrainingJobInSeconds = structure(logical(0), tags = list(type = "integer")), MaxAutoMLJobRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), SecurityConfig = structure(list(VolumeKmsKeyId = structure(logical(0), tags = list(type = "string")), EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), FailureReason = structure(logical(0), tags = list(type = "string")), BestCandidate = structure(list(CandidateName = structure(logical(0), tags = list(type = "string")), FinalAutoMLJobObjectiveMetric = structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "float"))), tags = list(type = "structure")), ObjectiveStatus = structure(logical(0), tags = list(type = "string")), CandidateSteps = structure(list(structure(list(CandidateStepType = structure(logical(0), tags = list(type = "string")), CandidateStepArn = structure(logical(0), tags = list(type = "string")), CandidateStepName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), CandidateStatus = structure(logical(0), tags = list(type = "string")), InferenceContainers = structure(list(structure(list(Image = structure(logical(0), tags = list(type = "string")), ModelDataUrl = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), AutoMLJobStatus = structure(logical(0), tags = list(type = "string")), AutoMLJobSecondaryStatus = structure(logical(0), tags = list(type = "string")), GenerateCandidateDefinitionsOnly = structure(logical(0), tags = list(type = "boolean")), AutoMLJobArtifacts = structure(list(CandidateDefinitionNotebookLocation = structure(logical(0), tags = list(type = "string")), DataExplorationNotebookLocation = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResolvedAttributes = structure(list(AutoMLJobObjective = structure(list(MetricName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ProblemType = structure(logical(0), tags = list(type = "string")), CompletionCriteria = structure(list(MaxCandidates = structure(logical(0), tags = list(type = "integer")), MaxRuntimePerTrainingJobInSeconds = structure(logical(0), tags = list(type = "integer")), MaxAutoMLJobRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_code_repository_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CodeRepositoryName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_code_repository_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CodeRepositoryName = structure(logical(0), tags = list(type = "string")), CodeRepositoryArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), GitConfig = structure(list(RepositoryUrl = structure(logical(0), tags = list(type = "string")), Branch = structure(logical(0), tags = list(type = "string")), SecretArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_compilation_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CompilationJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_compilation_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CompilationJobName = structure(logical(0), tags = list(type = "string")), CompilationJobArn = structure(logical(0), tags = list(type = "string")), CompilationJobStatus = structure(logical(0), tags = list(type = "string")), CompilationStartTime = structure(logical(0), tags = list(type = "timestamp")), CompilationEndTime = structure(logical(0), tags = list(type = "timestamp")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxWaitTimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), FailureReason = structure(logical(0), tags = list(type = "string")), ModelArtifacts = structure(list(S3ModelArtifacts = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ModelDigests = structure(list(ArtifactDigest = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), InputConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), DataInputConfig = structure(logical(0), tags = list(type = "string")), Framework = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), OutputConfig = structure(list(S3OutputLocation = structure(logical(0), tags = list(type = "string")), TargetDevice = structure(logical(0), tags = list(type = "string")), TargetPlatform = structure(list(Os = structure(logical(0), tags = list(type = "string")), Arch = structure(logical(0), tags = list(type = "string")), Accelerator = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CompilerOptions = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_context_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ContextName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_context_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ContextName = structure(logical(0), tags = list(type = "string")), ContextArn = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string")), SourceId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ContextType = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), Properties = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_data_quality_job_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_data_quality_job_definition_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionArn = structure(logical(0), tags = list(type = "string")), JobDefinitionName = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), DataQualityBaselineConfig = structure(list(BaseliningJobName = structure(logical(0), tags = list(type = "string")), ConstraintsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StatisticsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), DataQualityAppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ContainerEntrypoint = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), ContainerArguments = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), RecordPreprocessorSourceUri = structure(logical(0), tags = list(type = "string")), PostAnalyticsProcessorSourceUri = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure")), DataQualityJobInput = structure(list(EndpointInput = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), FeaturesAttribute = structure(logical(0), tags = list(type = "string")), InferenceAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityThresholdAttribute = structure(logical(0), tags = list(type = "double")), StartTimeOffset = structure(logical(0), tags = list(type = "string")), EndTimeOffset = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), DataQualityJobOutputConfig = structure(list(MonitoringOutputs = structure(list(structure(list(S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JobResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_device_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), DeviceName = structure(logical(0), tags = list(type = "string")), DeviceFleetName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_device_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceArn = structure(logical(0), tags = list(type = "string")), DeviceName = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), DeviceFleetName = structure(logical(0), tags = list(type = "string")), IotThingName = structure(logical(0), tags = list(type = "string")), RegistrationTime = structure(logical(0), tags = list(type = "timestamp")), LatestHeartbeat = structure(logical(0), tags = list(type = "timestamp")), Models = structure(list(structure(list(ModelName = structure(logical(0), tags = list(type = "string")), ModelVersion = structure(logical(0), tags = list(type = "string")), LatestSampleTime = structure(logical(0), tags = list(type = "timestamp")), LatestInference = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), MaxModels = structure(logical(0), tags = list(type = "integer")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_device_fleet_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceFleetName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_device_fleet_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceFleetName = structure(logical(0), tags = list(type = "string")), DeviceFleetArn = structure(logical(0), tags = list(type = "string")), OutputConfig = structure(list(S3OutputLocation = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Description = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), RoleArn = structure(logical(0), tags = list(type = "string")), IotRoleAlias = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_domain_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_domain_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainArn = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string")), DomainName = structure(logical(0), tags = list(type = "string")), HomeEfsFileSystemId = structure(logical(0), tags = list(type = "string")), SingleSignOnManagedApplicationInstanceId = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), FailureReason = structure(logical(0), tags = list(type = "string")), AuthMode = structure(logical(0), tags = list(type = "string")), DefaultUserSettings = structure(list(ExecutionRole = structure(logical(0), tags = list(type = "string")), SecurityGroups = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SharingSettings = structure(list(NotebookOutputOption = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), S3KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JupyterServerAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), KernelGatewayAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CustomImages = structure(list(structure(list(ImageName = structure(logical(0), tags = list(type = "string")), ImageVersionNumber = structure(logical(0), tags = list(box = TRUE, type = "integer")), AppImageConfigName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), TensorBoardAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure")), AppNetworkAccessType = structure(logical(0), tags = list(type = "string")), HomeEfsFileSystemKmsKeyId = structure(logical(0), tags = list(deprecated = TRUE, deprecatedMessage = "This property is deprecated, use KmsKeyId instead.", type = "string")), SubnetIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Url = structure(logical(0), tags = list(type = "string")), VpcId = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_edge_packaging_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EdgePackagingJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_edge_packaging_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EdgePackagingJobArn = structure(logical(0), tags = list(type = "string")), EdgePackagingJobName = structure(logical(0), tags = list(type = "string")), CompilationJobName = structure(logical(0), tags = list(type = "string")), ModelName = structure(logical(0), tags = list(type = "string")), ModelVersion = structure(logical(0), tags = list(type = "string")), RoleArn = structure(logical(0), tags = list(type = "string")), OutputConfig = structure(list(S3OutputLocation = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceKey = structure(logical(0), tags = list(type = "string")), EdgePackagingJobStatus = structure(logical(0), tags = list(type = "string")), EdgePackagingJobStatusMessage = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), ModelArtifact = structure(logical(0), tags = list(type = "string")), ModelSignature = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_endpoint_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_endpoint_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), EndpointArn = structure(logical(0), tags = list(type = "string")), EndpointConfigName = structure(logical(0), tags = list(type = "string")), ProductionVariants = structure(list(structure(list(VariantName = structure(logical(0), tags = list(type = "string")), DeployedImages = structure(list(structure(list(SpecifiedImage = structure(logical(0), tags = list(type = "string")), ResolvedImage = structure(logical(0), tags = list(type = "string")), ResolutionTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), CurrentWeight = structure(logical(0), tags = list(type = "float")), DesiredWeight = structure(logical(0), tags = list(type = "float")), CurrentInstanceCount = structure(logical(0), tags = list(type = "integer")), DesiredInstanceCount = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "list")), DataCaptureConfig = structure(list(EnableCapture = structure(logical(0), tags = list(type = "boolean")), CaptureStatus = structure(logical(0), tags = list(type = "string")), CurrentSamplingPercentage = structure(logical(0), tags = list(type = "integer")), DestinationS3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), EndpointStatus = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastDeploymentConfig = structure(list(BlueGreenUpdatePolicy = structure(list(TrafficRoutingConfiguration = structure(list(Type = structure(logical(0), tags = list(type = "string")), WaitIntervalInSeconds = structure(logical(0), tags = list(type = "integer")), CanarySize = structure(list(Type = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure")), TerminationWaitInSeconds = structure(logical(0), tags = list(type = "integer")), MaximumExecutionTimeoutInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), AutoRollbackConfiguration = structure(list(Alarms = structure(list(structure(list(AlarmName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_endpoint_config_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointConfigName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_endpoint_config_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointConfigName = structure(logical(0), tags = list(type = "string")), EndpointConfigArn = structure(logical(0), tags = list(type = "string")), ProductionVariants = structure(list(structure(list(VariantName = structure(logical(0), tags = list(type = "string")), ModelName = structure(logical(0), tags = list(type = "string")), InitialInstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), InitialVariantWeight = structure(logical(0), tags = list(type = "float")), AcceleratorType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), DataCaptureConfig = structure(list(EnableCapture = structure(logical(0), tags = list(type = "boolean")), InitialSamplingPercentage = structure(logical(0), tags = list(type = "integer")), DestinationS3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string")), CaptureOptions = structure(list(structure(list(CaptureMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), CaptureContentTypeHeader = structure(list(CsvContentTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), JsonContentTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), KmsKeyId = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_experiment_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ExperimentName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_experiment_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), ExperimentArn = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Description = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_feature_group_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(FeatureGroupName = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_feature_group_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(FeatureGroupArn = structure(logical(0), tags = list(type = "string")), FeatureGroupName = structure(logical(0), tags = list(type = "string")), RecordIdentifierFeatureName = structure(logical(0), tags = list(type = "string")), EventTimeFeatureName = structure(logical(0), tags = list(type = "string")), FeatureDefinitions = structure(list(structure(list(FeatureName = structure(logical(0), tags = list(type = "string")), FeatureType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), OnlineStoreConfig = structure(list(SecurityConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), EnableOnlineStore = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure")), OfflineStoreConfig = structure(list(S3StorageConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DisableGlueTableCreation = structure(logical(0), tags = list(type = "boolean")), DataCatalogConfig = structure(list(TableName = structure(logical(0), tags = list(type = "string")), Catalog = structure(logical(0), tags = list(type = "string")), Database = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), FeatureGroupStatus = structure(logical(0), tags = list(type = "string")), OfflineStoreStatus = structure(list(Status = structure(logical(0), tags = list(type = "string")), BlockedReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), FailureReason = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_flow_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(FlowDefinitionName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_flow_definition_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(FlowDefinitionArn = structure(logical(0), tags = list(type = "string")), FlowDefinitionName = structure(logical(0), tags = list(type = "string")), FlowDefinitionStatus = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), HumanLoopRequestSource = structure(list(AwsManagedHumanLoopRequestSource = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), HumanLoopActivationConfig = structure(list(HumanLoopActivationConditionsConfig = structure(list(HumanLoopActivationConditions = structure(logical(0), tags = list(jsonvalue = TRUE, type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), HumanLoopConfig = structure(list(WorkteamArn = structure(logical(0), tags = list(type = "string")), HumanTaskUiArn = structure(logical(0), tags = list(type = "string")), TaskTitle = structure(logical(0), tags = list(type = "string")), TaskDescription = structure(logical(0), tags = list(type = "string")), TaskCount = structure(logical(0), tags = list(type = "integer")), TaskAvailabilityLifetimeInSeconds = structure(logical(0), tags = list(type = "integer")), TaskTimeLimitInSeconds = structure(logical(0), tags = list(type = "integer")), TaskKeywords = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), PublicWorkforceTaskPrice = structure(list(AmountInUsd = structure(list(Dollars = structure(logical(0), tags = list(type = "integer")), Cents = structure(logical(0), tags = list(type = "integer")), TenthFractionsOfACent = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure")), OutputConfig = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_human_task_ui_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HumanTaskUiName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_human_task_ui_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HumanTaskUiArn = structure(logical(0), tags = list(type = "string")), HumanTaskUiName = structure(logical(0), tags = list(type = "string")), HumanTaskUiStatus = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), UiTemplate = structure(list(Url = structure(logical(0), tags = list(type = "string")), ContentSha256 = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_hyper_parameter_tuning_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HyperParameterTuningJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_hyper_parameter_tuning_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HyperParameterTuningJobName = structure(logical(0), tags = list(type = "string")), HyperParameterTuningJobArn = structure(logical(0), tags = list(type = "string")), HyperParameterTuningJobConfig = structure(list(Strategy = structure(logical(0), tags = list(type = "string")), HyperParameterTuningJobObjective = structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceLimits = structure(list(MaxNumberOfTrainingJobs = structure(logical(0), tags = list(type = "integer")), MaxParallelTrainingJobs = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), ParameterRanges = structure(list(IntegerParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string")), ScalingType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ContinuousParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string")), ScalingType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), CategoricalParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Values = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), TrainingJobEarlyStoppingType = structure(logical(0), tags = list(type = "string")), TuningJobCompletionCriteria = structure(list(TargetObjectiveMetricValue = structure(logical(0), tags = list(type = "float"))), tags = list(type = "structure"))), tags = list(type = "structure")), TrainingJobDefinition = structure(list(DefinitionName = structure(logical(0), tags = list(type = "string")), TuningObjective = structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), HyperParameterRanges = structure(list(IntegerParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string")), ScalingType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ContinuousParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string")), ScalingType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), CategoricalParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Values = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), StaticHyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), AlgorithmSpecification = structure(list(TrainingImage = structure(logical(0), tags = list(type = "string")), TrainingInputMode = structure(logical(0), tags = list(type = "string")), AlgorithmName = structure(logical(0), tags = list(type = "string")), MetricDefinitions = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Regex = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), InputDataConfig = structure(list(structure(list(ChannelName = structure(logical(0), tags = list(type = "string")), DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), AttributeNames = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), FileSystemDataSource = structure(list(FileSystemId = structure(logical(0), tags = list(type = "string")), FileSystemAccessMode = structure(logical(0), tags = list(type = "string")), FileSystemType = structure(logical(0), tags = list(type = "string")), DirectoryPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), RecordWrapperType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string")), ShuffleConfig = structure(list(Seed = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), OutputDataConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceConfig = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxWaitTimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableManagedSpotTraining = structure(logical(0), tags = list(type = "boolean")), CheckpointConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), TrainingJobDefinitions = structure(list(structure(list(DefinitionName = structure(logical(0), tags = list(type = "string")), TuningObjective = structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), HyperParameterRanges = structure(list(IntegerParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string")), ScalingType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ContinuousParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), MinValue = structure(logical(0), tags = list(type = "string")), MaxValue = structure(logical(0), tags = list(type = "string")), ScalingType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), CategoricalParameterRanges = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Values = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), StaticHyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), AlgorithmSpecification = structure(list(TrainingImage = structure(logical(0), tags = list(type = "string")), TrainingInputMode = structure(logical(0), tags = list(type = "string")), AlgorithmName = structure(logical(0), tags = list(type = "string")), MetricDefinitions = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Regex = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), InputDataConfig = structure(list(structure(list(ChannelName = structure(logical(0), tags = list(type = "string")), DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), AttributeNames = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), FileSystemDataSource = structure(list(FileSystemId = structure(logical(0), tags = list(type = "string")), FileSystemAccessMode = structure(logical(0), tags = list(type = "string")), FileSystemType = structure(logical(0), tags = list(type = "string")), DirectoryPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), RecordWrapperType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string")), ShuffleConfig = structure(list(Seed = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), OutputDataConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceConfig = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxWaitTimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableManagedSpotTraining = structure(logical(0), tags = list(type = "boolean")), CheckpointConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), HyperParameterTuningJobStatus = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), HyperParameterTuningEndTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), TrainingJobStatusCounters = structure(list(Completed = structure(logical(0), tags = list(type = "integer")), InProgress = structure(logical(0), tags = list(type = "integer")), RetryableError = structure(logical(0), tags = list(type = "integer")), NonRetryableError = structure(logical(0), tags = list(type = "integer")), Stopped = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), ObjectiveStatusCounters = structure(list(Succeeded = structure(logical(0), tags = list(type = "integer")), Pending = structure(logical(0), tags = list(type = "integer")), Failed = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), BestTrainingJob = structure(list(TrainingJobDefinitionName = structure(logical(0), tags = list(type = "string")), TrainingJobName = structure(logical(0), tags = list(type = "string")), TrainingJobArn = structure(logical(0), tags = list(type = "string")), TuningJobName = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), TrainingStartTime = structure(logical(0), tags = list(type = "timestamp")), TrainingEndTime = structure(logical(0), tags = list(type = "timestamp")), TrainingJobStatus = structure(logical(0), tags = list(type = "string")), TunedHyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), FailureReason = structure(logical(0), tags = list(type = "string")), FinalHyperParameterTuningJobObjectiveMetric = structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "float"))), tags = list(type = "structure")), ObjectiveStatus = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), OverallBestTrainingJob = structure(list(TrainingJobDefinitionName = structure(logical(0), tags = list(type = "string")), TrainingJobName = structure(logical(0), tags = list(type = "string")), TrainingJobArn = structure(logical(0), tags = list(type = "string")), TuningJobName = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), TrainingStartTime = structure(logical(0), tags = list(type = "timestamp")), TrainingEndTime = structure(logical(0), tags = list(type = "timestamp")), TrainingJobStatus = structure(logical(0), tags = list(type = "string")), TunedHyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), FailureReason = structure(logical(0), tags = list(type = "string")), FinalHyperParameterTuningJobObjectiveMetric = structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "float"))), tags = list(type = "structure")), ObjectiveStatus = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), WarmStartConfig = structure(list(ParentHyperParameterTuningJobs = structure(list(structure(list(HyperParameterTuningJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), WarmStartType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_image_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ImageName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_image_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTime = structure(logical(0), tags = list(type = "timestamp")), Description = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), ImageArn = structure(logical(0), tags = list(type = "string")), ImageName = structure(logical(0), tags = list(type = "string")), ImageStatus = structure(logical(0), tags = list(type = "string")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), RoleArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_image_version_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ImageName = structure(logical(0), tags = list(type = "string")), Version = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_image_version_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(BaseImage = structure(logical(0), tags = list(type = "string")), ContainerImage = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), FailureReason = structure(logical(0), tags = list(type = "string")), ImageArn = structure(logical(0), tags = list(type = "string")), ImageVersionArn = structure(logical(0), tags = list(type = "string")), ImageVersionStatus = structure(logical(0), tags = list(type = "string")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), Version = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_labeling_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(LabelingJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_labeling_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(LabelingJobStatus = structure(logical(0), tags = list(type = "string")), LabelCounters = structure(list(TotalLabeled = structure(logical(0), tags = list(type = "integer")), HumanLabeled = structure(logical(0), tags = list(type = "integer")), MachineLabeled = structure(logical(0), tags = list(type = "integer")), FailedNonRetryableError = structure(logical(0), tags = list(type = "integer")), Unlabeled = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), FailureReason = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), JobReferenceCode = structure(logical(0), tags = list(type = "string")), LabelingJobName = structure(logical(0), tags = list(type = "string")), LabelingJobArn = structure(logical(0), tags = list(type = "string")), LabelAttributeName = structure(logical(0), tags = list(type = "string")), InputConfig = structure(list(DataSource = structure(list(S3DataSource = structure(list(ManifestS3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), SnsDataSource = structure(list(SnsTopicArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), DataAttributes = structure(list(ContentClassifiers = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), OutputConfig = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string")), SnsTopicArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), LabelCategoryConfigS3Uri = structure(logical(0), tags = list(type = "string")), StoppingConditions = structure(list(MaxHumanLabeledObjectCount = structure(logical(0), tags = list(type = "integer")), MaxPercentageOfInputDatasetLabeled = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), LabelingJobAlgorithmsConfig = structure(list(LabelingJobAlgorithmSpecificationArn = structure(logical(0), tags = list(type = "string")), InitialActiveLearningModelArn = structure(logical(0), tags = list(type = "string")), LabelingJobResourceConfig = structure(list(VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), HumanTaskConfig = structure(list(WorkteamArn = structure(logical(0), tags = list(type = "string")), UiConfig = structure(list(UiTemplateS3Uri = structure(logical(0), tags = list(type = "string")), HumanTaskUiArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), PreHumanTaskLambdaArn = structure(logical(0), tags = list(type = "string")), TaskKeywords = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), TaskTitle = structure(logical(0), tags = list(type = "string")), TaskDescription = structure(logical(0), tags = list(type = "string")), NumberOfHumanWorkersPerDataObject = structure(logical(0), tags = list(type = "integer")), TaskTimeLimitInSeconds = structure(logical(0), tags = list(type = "integer")), TaskAvailabilityLifetimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxConcurrentTaskCount = structure(logical(0), tags = list(type = "integer")), AnnotationConsolidationConfig = structure(list(AnnotationConsolidationLambdaArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), PublicWorkforceTaskPrice = structure(list(AmountInUsd = structure(list(Dollars = structure(logical(0), tags = list(type = "integer")), Cents = structure(logical(0), tags = list(type = "integer")), TenthFractionsOfACent = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), LabelingJobOutput = structure(list(OutputDatasetS3Uri = structure(logical(0), tags = list(type = "string")), FinalActiveLearningModelArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_model_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_model_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelName = structure(logical(0), tags = list(type = "string")), PrimaryContainer = structure(list(ContainerHostname = structure(logical(0), tags = list(type = "string")), Image = structure(logical(0), tags = list(type = "string")), ImageConfig = structure(list(RepositoryAccessMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Mode = structure(logical(0), tags = list(type = "string")), ModelDataUrl = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), ModelPackageName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Containers = structure(list(structure(list(ContainerHostname = structure(logical(0), tags = list(type = "string")), Image = structure(logical(0), tags = list(type = "string")), ImageConfig = structure(list(RepositoryAccessMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Mode = structure(logical(0), tags = list(type = "string")), ModelDataUrl = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), ModelPackageName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ExecutionRoleArn = structure(logical(0), tags = list(type = "string")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), ModelArn = structure(logical(0), tags = list(type = "string")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_model_bias_job_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_model_bias_job_definition_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionArn = structure(logical(0), tags = list(type = "string")), JobDefinitionName = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), ModelBiasBaselineConfig = structure(list(BaseliningJobName = structure(logical(0), tags = list(type = "string")), ConstraintsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelBiasAppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ConfigUri = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure")), ModelBiasJobInput = structure(list(EndpointInput = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), FeaturesAttribute = structure(logical(0), tags = list(type = "string")), InferenceAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityThresholdAttribute = structure(logical(0), tags = list(type = "double")), StartTimeOffset = structure(logical(0), tags = list(type = "string")), EndTimeOffset = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), GroundTruthS3Input = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelBiasJobOutputConfig = structure(list(MonitoringOutputs = structure(list(structure(list(S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JobResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_model_explainability_job_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_model_explainability_job_definition_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionArn = structure(logical(0), tags = list(type = "string")), JobDefinitionName = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), ModelExplainabilityBaselineConfig = structure(list(BaseliningJobName = structure(logical(0), tags = list(type = "string")), ConstraintsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelExplainabilityAppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ConfigUri = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure")), ModelExplainabilityJobInput = structure(list(EndpointInput = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), FeaturesAttribute = structure(logical(0), tags = list(type = "string")), InferenceAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityThresholdAttribute = structure(logical(0), tags = list(type = "double")), StartTimeOffset = structure(logical(0), tags = list(type = "string")), EndTimeOffset = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelExplainabilityJobOutputConfig = structure(list(MonitoringOutputs = structure(list(structure(list(S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JobResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_model_package_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_model_package_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageName = structure(logical(0), tags = list(type = "string")), ModelPackageGroupName = structure(logical(0), tags = list(type = "string")), ModelPackageVersion = structure(logical(0), tags = list(type = "integer")), ModelPackageArn = structure(logical(0), tags = list(type = "string")), ModelPackageDescription = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), InferenceSpecification = structure(list(Containers = structure(list(structure(list(ContainerHostname = structure(logical(0), tags = list(type = "string")), Image = structure(logical(0), tags = list(type = "string")), ImageDigest = structure(logical(0), tags = list(type = "string")), ModelDataUrl = structure(logical(0), tags = list(type = "string")), ProductId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), SupportedTransformInstanceTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedRealtimeInferenceInstanceTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedContentTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedResponseMIMETypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), SourceAlgorithmSpecification = structure(list(SourceAlgorithms = structure(list(structure(list(ModelDataUrl = structure(logical(0), tags = list(type = "string")), AlgorithmName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ValidationSpecification = structure(list(ValidationRole = structure(logical(0), tags = list(type = "string")), ValidationProfiles = structure(list(structure(list(ProfileName = structure(logical(0), tags = list(type = "string")), TransformJobDefinition = structure(list(MaxConcurrentTransforms = structure(logical(0), tags = list(type = "integer")), MaxPayloadInMB = structure(logical(0), tags = list(type = "integer")), BatchStrategy = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), TransformInput = structure(list(DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), SplitType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformOutput = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), Accept = structure(logical(0), tags = list(type = "string")), AssembleWith = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformResources = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ModelPackageStatus = structure(logical(0), tags = list(type = "string")), ModelPackageStatusDetails = structure(list(ValidationStatuses = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ImageScanStatuses = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), CertifyForMarketplace = structure(logical(0), tags = list(type = "boolean")), ModelApprovalStatus = structure(logical(0), tags = list(type = "string")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ModelMetrics = structure(list(ModelQuality = structure(list(Statistics = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Constraints = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelDataQuality = structure(list(Statistics = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Constraints = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), Bias = structure(list(Report = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), Explainability = structure(list(Report = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ApprovalDescription = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_model_package_group_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageGroupName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_model_package_group_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageGroupName = structure(logical(0), tags = list(type = "string")), ModelPackageGroupArn = structure(logical(0), tags = list(type = "string")), ModelPackageGroupDescription = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ModelPackageGroupStatus = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_model_quality_job_definition_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_model_quality_job_definition_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionArn = structure(logical(0), tags = list(type = "string")), JobDefinitionName = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), ModelQualityBaselineConfig = structure(list(BaseliningJobName = structure(logical(0), tags = list(type = "string")), ConstraintsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelQualityAppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ContainerEntrypoint = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), ContainerArguments = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), RecordPreprocessorSourceUri = structure(logical(0), tags = list(type = "string")), PostAnalyticsProcessorSourceUri = structure(logical(0), tags = list(type = "string")), ProblemType = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure")), ModelQualityJobInput = structure(list(EndpointInput = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), FeaturesAttribute = structure(logical(0), tags = list(type = "string")), InferenceAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityThresholdAttribute = structure(logical(0), tags = list(type = "double")), StartTimeOffset = structure(logical(0), tags = list(type = "string")), EndTimeOffset = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), GroundTruthS3Input = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelQualityJobOutputConfig = structure(list(MonitoringOutputs = structure(list(structure(list(S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JobResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_monitoring_schedule_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MonitoringScheduleName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_monitoring_schedule_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MonitoringScheduleArn = structure(logical(0), tags = list(type = "string")), MonitoringScheduleName = structure(logical(0), tags = list(type = "string")), MonitoringScheduleStatus = structure(logical(0), tags = list(type = "string")), MonitoringType = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), MonitoringScheduleConfig = structure(list(ScheduleConfig = structure(list(ScheduleExpression = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MonitoringJobDefinition = structure(list(BaselineConfig = structure(list(BaseliningJobName = structure(logical(0), tags = list(type = "string")), ConstraintsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StatisticsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), MonitoringInputs = structure(list(structure(list(EndpointInput = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), FeaturesAttribute = structure(logical(0), tags = list(type = "string")), InferenceAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityThresholdAttribute = structure(logical(0), tags = list(type = "double")), StartTimeOffset = structure(logical(0), tags = list(type = "string")), EndTimeOffset = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), MonitoringOutputConfig = structure(list(MonitoringOutputs = structure(list(structure(list(S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MonitoringResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), MonitoringAppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ContainerEntrypoint = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), ContainerArguments = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), RecordPreprocessorSourceUri = structure(logical(0), tags = list(type = "string")), PostAnalyticsProcessorSourceUri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), EndpointName = structure(logical(0), tags = list(type = "string")), LastMonitoringExecutionSummary = structure(list(MonitoringScheduleName = structure(logical(0), tags = list(type = "string")), ScheduledTime = structure(logical(0), tags = list(type = "timestamp")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), MonitoringExecutionStatus = structure(logical(0), tags = list(type = "string")), ProcessingJobArn = structure(logical(0), tags = list(type = "string")), EndpointName = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_notebook_instance_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_notebook_instance_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceArn = structure(logical(0), tags = list(type = "string")), NotebookInstanceName = structure(logical(0), tags = list(type = "string")), NotebookInstanceStatus = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), Url = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string")), SubnetId = structure(logical(0), tags = list(type = "string")), SecurityGroups = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), RoleArn = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string")), NetworkInterfaceId = structure(logical(0), tags = list(type = "string")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), NotebookInstanceLifecycleConfigName = structure(logical(0), tags = list(type = "string")), DirectInternetAccess = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), AcceleratorTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), DefaultCodeRepository = structure(logical(0), tags = list(type = "string")), AdditionalCodeRepositories = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), RootAccess = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_notebook_instance_lifecycle_config_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceLifecycleConfigName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_notebook_instance_lifecycle_config_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceLifecycleConfigArn = structure(logical(0), tags = list(type = "string")), NotebookInstanceLifecycleConfigName = structure(logical(0), tags = list(type = "string")), OnCreate = structure(list(structure(list(Content = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), OnStart = structure(list(structure(list(Content = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), CreationTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_pipeline_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_pipeline_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineArn = structure(logical(0), tags = list(type = "string")), PipelineName = structure(logical(0), tags = list(type = "string")), PipelineDisplayName = structure(logical(0), tags = list(type = "string")), PipelineDefinition = structure(logical(0), tags = list(type = "string")), PipelineDescription = structure(logical(0), tags = list(type = "string")), RoleArn = structure(logical(0), tags = list(type = "string")), PipelineStatus = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastRunTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_pipeline_definition_for_execution_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineExecutionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_pipeline_definition_for_execution_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineDefinition = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_pipeline_execution_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineExecutionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_pipeline_execution_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineArn = structure(logical(0), tags = list(type = "string")), PipelineExecutionArn = structure(logical(0), tags = list(type = "string")), PipelineExecutionDisplayName = structure(logical(0), tags = list(type = "string")), PipelineExecutionStatus = structure(logical(0), tags = list(type = "string")), PipelineExecutionDescription = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_processing_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ProcessingJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_processing_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ProcessingInputs = structure(list(structure(list(InputName = structure(logical(0), tags = list(type = "string")), AppManaged = structure(logical(0), tags = list(type = "boolean")), S3Input = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3DataType = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), S3CompressionType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DatasetDefinition = structure(list(AthenaDatasetDefinition = structure(list(Catalog = structure(logical(0), tags = list(type = "string")), Database = structure(logical(0), tags = list(type = "string")), QueryString = structure(logical(0), tags = list(type = "string")), WorkGroup = structure(logical(0), tags = list(type = "string")), OutputS3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string")), OutputFormat = structure(logical(0), tags = list(type = "string")), OutputCompression = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), RedshiftDatasetDefinition = structure(list(ClusterId = structure(logical(0), tags = list(type = "string")), Database = structure(logical(0), tags = list(type = "string")), DbUser = structure(logical(0), tags = list(type = "string")), QueryString = structure(logical(0), tags = list(type = "string")), ClusterRoleArn = structure(logical(0), tags = list(type = "string")), OutputS3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string")), OutputFormat = structure(logical(0), tags = list(type = "string")), OutputCompression = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LocalPath = structure(logical(0), tags = list(type = "string")), DataDistributionType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), ProcessingOutputConfig = structure(list(Outputs = structure(list(structure(list(OutputName = structure(logical(0), tags = list(type = "string")), S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), FeatureStoreOutput = structure(list(FeatureGroupName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), AppManaged = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ProcessingJobName = structure(logical(0), tags = list(type = "string")), ProcessingResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), AppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ContainerEntrypoint = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), ContainerArguments = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), ExperimentConfig = structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string")), TrialComponentDisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ProcessingJobArn = structure(logical(0), tags = list(type = "string")), ProcessingJobStatus = structure(logical(0), tags = list(type = "string")), ExitMessage = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), ProcessingEndTime = structure(logical(0), tags = list(type = "timestamp")), ProcessingStartTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), MonitoringScheduleArn = structure(logical(0), tags = list(type = "string")), AutoMLJobArn = structure(logical(0), tags = list(type = "string")), TrainingJobArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_project_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ProjectName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_project_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ProjectArn = structure(logical(0), tags = list(type = "string")), ProjectName = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string")), ProjectDescription = structure(logical(0), tags = list(type = "string")), ServiceCatalogProvisioningDetails = structure(list(ProductId = structure(logical(0), tags = list(type = "string")), ProvisioningArtifactId = structure(logical(0), tags = list(type = "string")), PathId = structure(logical(0), tags = list(type = "string")), ProvisioningParameters = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ServiceCatalogProvisionedProductDetails = structure(list(ProvisionedProductId = structure(logical(0), tags = list(type = "string")), ProvisionedProductStatusMessage = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ProjectStatus = structure(logical(0), tags = list(type = "string")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_subscribed_workteam_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(WorkteamArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_subscribed_workteam_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SubscribedWorkteam = structure(list(WorkteamArn = structure(logical(0), tags = list(type = "string")), MarketplaceTitle = structure(logical(0), tags = list(type = "string")), SellerName = structure(logical(0), tags = list(type = "string")), MarketplaceDescription = structure(logical(0), tags = list(type = "string")), ListingId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_training_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrainingJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_training_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrainingJobName = structure(logical(0), tags = list(type = "string")), TrainingJobArn = structure(logical(0), tags = list(type = "string")), TuningJobArn = structure(logical(0), tags = list(type = "string")), LabelingJobArn = structure(logical(0), tags = list(type = "string")), AutoMLJobArn = structure(logical(0), tags = list(type = "string")), ModelArtifacts = structure(list(S3ModelArtifacts = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TrainingJobStatus = structure(logical(0), tags = list(type = "string")), SecondaryStatus = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), HyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), AlgorithmSpecification = structure(list(TrainingImage = structure(logical(0), tags = list(type = "string")), AlgorithmName = structure(logical(0), tags = list(type = "string")), TrainingInputMode = structure(logical(0), tags = list(type = "string")), MetricDefinitions = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Regex = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), EnableSageMakerMetricsTimeSeries = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), InputDataConfig = structure(list(structure(list(ChannelName = structure(logical(0), tags = list(type = "string")), DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), AttributeNames = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), FileSystemDataSource = structure(list(FileSystemId = structure(logical(0), tags = list(type = "string")), FileSystemAccessMode = structure(logical(0), tags = list(type = "string")), FileSystemType = structure(logical(0), tags = list(type = "string")), DirectoryPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), RecordWrapperType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string")), ShuffleConfig = structure(list(Seed = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), OutputDataConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceConfig = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxWaitTimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), TrainingStartTime = structure(logical(0), tags = list(type = "timestamp")), TrainingEndTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), SecondaryStatusTransitions = structure(list(structure(list(Status = structure(logical(0), tags = list(type = "string")), StartTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), StatusMessage = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), FinalMetricDataList = structure(list(structure(list(MetricName = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "float")), Timestamp = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableManagedSpotTraining = structure(logical(0), tags = list(type = "boolean")), CheckpointConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TrainingTimeInSeconds = structure(logical(0), tags = list(type = "integer")), BillableTimeInSeconds = structure(logical(0), tags = list(type = "integer")), DebugHookConfig = structure(list(LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), HookParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), CollectionConfigurations = structure(list(structure(list(CollectionName = structure(logical(0), tags = list(type = "string")), CollectionParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ExperimentConfig = structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string")), TrialComponentDisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DebugRuleConfigurations = structure(list(structure(list(RuleConfigurationName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), RuleEvaluatorImage = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), RuleParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list")), TensorBoardOutputConfig = structure(list(LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DebugRuleEvaluationStatuses = structure(list(structure(list(RuleConfigurationName = structure(logical(0), tags = list(type = "string")), RuleEvaluationJobArn = structure(logical(0), tags = list(type = "string")), RuleEvaluationStatus = structure(logical(0), tags = list(type = "string")), StatusDetails = structure(logical(0), tags = list(type = "string")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), ProfilerConfig = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), ProfilingIntervalInMilliseconds = structure(logical(0), tags = list(type = "long")), ProfilingParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure")), ProfilerRuleConfigurations = structure(list(structure(list(RuleConfigurationName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), RuleEvaluatorImage = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), RuleParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list")), ProfilerRuleEvaluationStatuses = structure(list(structure(list(RuleConfigurationName = structure(logical(0), tags = list(type = "string")), RuleEvaluationJobArn = structure(logical(0), tags = list(type = "string")), RuleEvaluationStatus = structure(logical(0), tags = list(type = "string")), StatusDetails = structure(logical(0), tags = list(type = "string")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), ProfilingStatus = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_transform_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TransformJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_transform_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TransformJobName = structure(logical(0), tags = list(type = "string")), TransformJobArn = structure(logical(0), tags = list(type = "string")), TransformJobStatus = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), ModelName = structure(logical(0), tags = list(type = "string")), MaxConcurrentTransforms = structure(logical(0), tags = list(type = "integer")), ModelClientConfig = structure(list(InvocationsTimeoutInSeconds = structure(logical(0), tags = list(type = "integer")), InvocationsMaxRetries = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), MaxPayloadInMB = structure(logical(0), tags = list(type = "integer")), BatchStrategy = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), TransformInput = structure(list(DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), SplitType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformOutput = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), Accept = structure(logical(0), tags = list(type = "string")), AssembleWith = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformResources = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), TransformStartTime = structure(logical(0), tags = list(type = "timestamp")), TransformEndTime = structure(logical(0), tags = list(type = "timestamp")), LabelingJobArn = structure(logical(0), tags = list(type = "string")), AutoMLJobArn = structure(logical(0), tags = list(type = "string")), DataProcessing = structure(list(InputFilter = structure(logical(0), tags = list(type = "string")), OutputFilter = structure(logical(0), tags = list(type = "string")), JoinSource = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ExperimentConfig = structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string")), TrialComponentDisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_trial_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_trial_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialName = structure(logical(0), tags = list(type = "string")), TrialArn = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), ExperimentName = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_trial_component_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_trial_component_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentName = structure(logical(0), tags = list(type = "string")), TrialComponentArn = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Status = structure(list(PrimaryStatus = structure(logical(0), tags = list(type = "string")), Message = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StartTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Parameters = structure(list(structure(list(StringValue = structure(logical(0), tags = list(type = "string")), NumberValue = structure(logical(0), tags = list(type = "double"))), tags = list(type = "structure"))), tags = list(type = "map")), InputArtifacts = structure(list(structure(list(MediaType = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "map")), OutputArtifacts = structure(list(structure(list(MediaType = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "map")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Metrics = structure(list(structure(list(MetricName = structure(logical(0), tags = list(type = "string")), SourceArn = structure(logical(0), tags = list(type = "string")), TimeStamp = structure(logical(0), tags = list(type = "timestamp")), Max = structure(logical(0), tags = list(type = "double")), Min = structure(logical(0), tags = list(type = "double")), Last = structure(logical(0), tags = list(type = "double")), Count = structure(logical(0), tags = list(type = "integer")), Avg = structure(logical(0), tags = list(type = "double")), StdDev = structure(logical(0), tags = list(type = "double"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_user_profile_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainId = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_user_profile_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainId = structure(logical(0), tags = list(type = "string")), UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), HomeEfsFileSystemUid = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), FailureReason = structure(logical(0), tags = list(type = "string")), SingleSignOnUserIdentifier = structure(logical(0), tags = list(type = "string")), SingleSignOnUserValue = structure(logical(0), tags = list(type = "string")), UserSettings = structure(list(ExecutionRole = structure(logical(0), tags = list(type = "string")), SecurityGroups = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SharingSettings = structure(list(NotebookOutputOption = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), S3KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JupyterServerAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), KernelGatewayAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CustomImages = structure(list(structure(list(ImageName = structure(logical(0), tags = list(type = "string")), ImageVersionNumber = structure(logical(0), tags = list(box = TRUE, type = "integer")), AppImageConfigName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), TensorBoardAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_workforce_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(WorkforceName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_workforce_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Workforce = structure(list(WorkforceName = structure(logical(0), tags = list(type = "string")), WorkforceArn = structure(logical(0), tags = list(type = "string")), LastUpdatedDate = structure(logical(0), tags = list(type = "timestamp")), SourceIpConfig = structure(list(Cidrs = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), SubDomain = structure(logical(0), tags = list(type = "string")), CognitoConfig = structure(list(UserPool = structure(logical(0), tags = list(type = "string")), ClientId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), OidcConfig = structure(list(ClientId = structure(logical(0), tags = list(type = "string")), Issuer = structure(logical(0), tags = list(type = "string")), AuthorizationEndpoint = structure(logical(0), tags = list(type = "string")), TokenEndpoint = structure(logical(0), tags = list(type = "string")), UserInfoEndpoint = structure(logical(0), tags = list(type = "string")), LogoutEndpoint = structure(logical(0), tags = list(type = "string")), JwksUri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CreateDate = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_workteam_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(WorkteamName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$describe_workteam_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Workteam = structure(list(WorkteamName = structure(logical(0), tags = list(type = "string")), MemberDefinitions = structure(list(structure(list(CognitoMemberDefinition = structure(list(UserPool = structure(logical(0), tags = list(type = "string")), UserGroup = structure(logical(0), tags = list(type = "string")), ClientId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), OidcMemberDefinition = structure(list(Groups = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), WorkteamArn = structure(logical(0), tags = list(type = "string")), WorkforceArn = structure(logical(0), tags = list(type = "string")), ProductListingIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Description = structure(logical(0), tags = list(type = "string")), SubDomain = structure(logical(0), tags = list(type = "string")), CreateDate = structure(logical(0), tags = list(type = "timestamp")), LastUpdatedDate = structure(logical(0), tags = list(type = "timestamp")), NotificationConfiguration = structure(list(NotificationTopicArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$disable_sagemaker_servicecatalog_portfolio_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$disable_sagemaker_servicecatalog_portfolio_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$disassociate_trial_component_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$disassociate_trial_component_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentArn = structure(logical(0), tags = list(type = "string")), TrialArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$enable_sagemaker_servicecatalog_portfolio_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$enable_sagemaker_servicecatalog_portfolio_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$get_device_fleet_report_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceFleetName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$get_device_fleet_report_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceFleetArn = structure(logical(0), tags = list(type = "string")), DeviceFleetName = structure(logical(0), tags = list(type = "string")), OutputConfig = structure(list(S3OutputLocation = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Description = structure(logical(0), tags = list(type = "string")), ReportGenerated = structure(logical(0), tags = list(type = "timestamp")), DeviceStats = structure(list(ConnectedDeviceCount = structure(logical(0), tags = list(type = "long")), RegisteredDeviceCount = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure")), AgentVersions = structure(list(structure(list(Version = structure(logical(0), tags = list(type = "string")), AgentCount = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure"))), tags = list(type = "list")), ModelStats = structure(list(structure(list(ModelName = structure(logical(0), tags = list(type = "string")), ModelVersion = structure(logical(0), tags = list(type = "string")), OfflineDeviceCount = structure(logical(0), tags = list(type = "long")), ConnectedDeviceCount = structure(logical(0), tags = list(type = "long")), ActiveDeviceCount = structure(logical(0), tags = list(type = "long")), SamplingDeviceCount = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$get_model_package_group_policy_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageGroupName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$get_model_package_group_policy_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ResourcePolicy = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$get_sagemaker_servicecatalog_portfolio_status_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$get_sagemaker_servicecatalog_portfolio_status_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Status = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$get_search_suggestions_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Resource = structure(logical(0), tags = list(type = "string")), SuggestionQuery = structure(list(PropertyNameQuery = structure(list(PropertyNameHint = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$get_search_suggestions_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PropertyNameSuggestions = structure(list(structure(list(PropertyName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_actions_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), ActionType = structure(logical(0), tags = list(type = "string")), CreatedAfter = structure(logical(0), tags = list(type = "timestamp")), CreatedBefore = structure(logical(0), tags = list(type = "timestamp")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_actions_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ActionSummaries = structure(list(structure(list(ActionArn = structure(logical(0), tags = list(type = "string")), ActionName = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string")), SourceId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ActionType = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_algorithms_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_algorithms_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AlgorithmSummaryList = structure(list(structure(list(AlgorithmName = structure(logical(0), tags = list(type = "string")), AlgorithmArn = structure(logical(0), tags = list(type = "string")), AlgorithmDescription = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), AlgorithmStatus = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_app_image_configs_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MaxResults = structure(logical(0), tags = list(type = "integer")), NextToken = structure(logical(0), tags = list(type = "string")), NameContains = structure(logical(0), tags = list(type = "string")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), ModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), ModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_app_image_configs_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), AppImageConfigs = structure(list(structure(list(AppImageConfigArn = structure(logical(0), tags = list(type = "string")), AppImageConfigName = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), KernelGatewayImageConfig = structure(list(KernelSpecs = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), FileSystemConfig = structure(list(MountPath = structure(logical(0), tags = list(type = "string")), DefaultUid = structure(logical(0), tags = list(box = TRUE, type = "integer")), DefaultGid = structure(logical(0), tags = list(box = TRUE, type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_apps_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), SortOrder = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), DomainIdEquals = structure(logical(0), tags = list(type = "string")), UserProfileNameEquals = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_apps_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Apps = structure(list(structure(list(DomainId = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), AppType = structure(logical(0), tags = list(type = "string")), AppName = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_artifacts_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), ArtifactType = structure(logical(0), tags = list(type = "string")), CreatedAfter = structure(logical(0), tags = list(type = "timestamp")), CreatedBefore = structure(logical(0), tags = list(type = "timestamp")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_artifacts_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ArtifactSummaries = structure(list(structure(list(ArtifactArn = structure(logical(0), tags = list(type = "string")), ArtifactName = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), SourceTypes = structure(list(structure(list(SourceIdType = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ArtifactType = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_associations_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), DestinationArn = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string")), DestinationType = structure(logical(0), tags = list(type = "string")), AssociationType = structure(logical(0), tags = list(type = "string")), CreatedAfter = structure(logical(0), tags = list(type = "timestamp")), CreatedBefore = structure(logical(0), tags = list(type = "timestamp")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_associations_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AssociationSummaries = structure(list(structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), DestinationArn = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string")), DestinationType = structure(logical(0), tags = list(type = "string")), AssociationType = structure(logical(0), tags = list(type = "string")), SourceName = structure(logical(0), tags = list(type = "string")), DestinationName = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_auto_ml_jobs_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), NameContains = structure(logical(0), tags = list(type = "string")), StatusEquals = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_auto_ml_jobs_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AutoMLJobSummaries = structure(list(structure(list(AutoMLJobName = structure(logical(0), tags = list(type = "string")), AutoMLJobArn = structure(logical(0), tags = list(type = "string")), AutoMLJobStatus = structure(logical(0), tags = list(type = "string")), AutoMLJobSecondaryStatus = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_candidates_for_auto_ml_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AutoMLJobName = structure(logical(0), tags = list(type = "string")), StatusEquals = structure(logical(0), tags = list(type = "string")), CandidateNameEquals = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_candidates_for_auto_ml_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Candidates = structure(list(structure(list(CandidateName = structure(logical(0), tags = list(type = "string")), FinalAutoMLJobObjectiveMetric = structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "float"))), tags = list(type = "structure")), ObjectiveStatus = structure(logical(0), tags = list(type = "string")), CandidateSteps = structure(list(structure(list(CandidateStepType = structure(logical(0), tags = list(type = "string")), CandidateStepArn = structure(logical(0), tags = list(type = "string")), CandidateStepName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), CandidateStatus = structure(logical(0), tags = list(type = "string")), InferenceContainers = structure(list(structure(list(Image = structure(logical(0), tags = list(type = "string")), ModelDataUrl = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_code_repositories_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_code_repositories_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CodeRepositorySummaryList = structure(list(structure(list(CodeRepositoryName = structure(logical(0), tags = list(type = "string")), CodeRepositoryArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), GitConfig = structure(list(RepositoryUrl = structure(logical(0), tags = list(type = "string")), Branch = structure(logical(0), tags = list(type = "string")), SecretArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_compilation_jobs_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), NameContains = structure(logical(0), tags = list(type = "string")), StatusEquals = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_compilation_jobs_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CompilationJobSummaries = structure(list(structure(list(CompilationJobName = structure(logical(0), tags = list(type = "string")), CompilationJobArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CompilationStartTime = structure(logical(0), tags = list(type = "timestamp")), CompilationEndTime = structure(logical(0), tags = list(type = "timestamp")), CompilationTargetDevice = structure(logical(0), tags = list(type = "string")), CompilationTargetPlatformOs = structure(logical(0), tags = list(type = "string")), CompilationTargetPlatformArch = structure(logical(0), tags = list(type = "string")), CompilationTargetPlatformAccelerator = structure(logical(0), tags = list(type = "string")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), CompilationJobStatus = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_contexts_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), ContextType = structure(logical(0), tags = list(type = "string")), CreatedAfter = structure(logical(0), tags = list(type = "timestamp")), CreatedBefore = structure(logical(0), tags = list(type = "timestamp")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_contexts_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ContextSummaries = structure(list(structure(list(ContextArn = structure(logical(0), tags = list(type = "string")), ContextName = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceUri = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string")), SourceId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ContextType = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_data_quality_job_definitions_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_data_quality_job_definitions_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionSummaries = structure(list(structure(list(MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringJobDefinitionArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), EndpointName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_device_fleets_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), NameContains = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_device_fleets_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceFleetSummaries = structure(list(structure(list(DeviceFleetArn = structure(logical(0), tags = list(type = "string")), DeviceFleetName = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_devices_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer")), LatestHeartbeatAfter = structure(logical(0), tags = list(type = "timestamp")), ModelName = structure(logical(0), tags = list(type = "string")), DeviceFleetName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_devices_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceSummaries = structure(list(structure(list(DeviceName = structure(logical(0), tags = list(type = "string")), DeviceArn = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), DeviceFleetName = structure(logical(0), tags = list(type = "string")), IotThingName = structure(logical(0), tags = list(type = "string")), RegistrationTime = structure(logical(0), tags = list(type = "timestamp")), LatestHeartbeat = structure(logical(0), tags = list(type = "timestamp")), Models = structure(list(structure(list(ModelName = structure(logical(0), tags = list(type = "string")), ModelVersion = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_domains_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_domains_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Domains = structure(list(structure(list(DomainArn = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string")), DomainName = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), Url = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_edge_packaging_jobs_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), NameContains = structure(logical(0), tags = list(type = "string")), ModelNameContains = structure(logical(0), tags = list(type = "string")), StatusEquals = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_edge_packaging_jobs_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EdgePackagingJobSummaries = structure(list(structure(list(EdgePackagingJobArn = structure(logical(0), tags = list(type = "string")), EdgePackagingJobName = structure(logical(0), tags = list(type = "string")), EdgePackagingJobStatus = structure(logical(0), tags = list(type = "string")), CompilationJobName = structure(logical(0), tags = list(type = "string")), ModelName = structure(logical(0), tags = list(type = "string")), ModelVersion = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_endpoint_configs_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_endpoint_configs_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointConfigs = structure(list(structure(list(EndpointConfigName = structure(logical(0), tags = list(type = "string")), EndpointConfigArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_endpoints_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), StatusEquals = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_endpoints_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Endpoints = structure(list(structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), EndpointArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), EndpointStatus = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_experiments_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreatedAfter = structure(logical(0), tags = list(type = "timestamp")), CreatedBefore = structure(logical(0), tags = list(type = "timestamp")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_experiments_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ExperimentSummaries = structure(list(structure(list(ExperimentArn = structure(logical(0), tags = list(type = "string")), ExperimentName = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), ExperimentSource = structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_feature_groups_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NameContains = structure(logical(0), tags = list(type = "string")), FeatureGroupStatusEquals = structure(logical(0), tags = list(type = "string")), OfflineStoreStatusEquals = structure(logical(0), tags = list(type = "string")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), SortOrder = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_feature_groups_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(FeatureGroupSummaries = structure(list(structure(list(FeatureGroupName = structure(logical(0), tags = list(type = "string")), FeatureGroupArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), FeatureGroupStatus = structure(logical(0), tags = list(type = "string")), OfflineStoreStatus = structure(list(Status = structure(logical(0), tags = list(type = "string")), BlockedReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_flow_definitions_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_flow_definitions_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(FlowDefinitionSummaries = structure(list(structure(list(FlowDefinitionName = structure(logical(0), tags = list(type = "string")), FlowDefinitionArn = structure(logical(0), tags = list(type = "string")), FlowDefinitionStatus = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_human_task_uis_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_human_task_uis_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HumanTaskUiSummaries = structure(list(structure(list(HumanTaskUiName = structure(logical(0), tags = list(type = "string")), HumanTaskUiArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_hyper_parameter_tuning_jobs_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NameContains = structure(logical(0), tags = list(type = "string")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), StatusEquals = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_hyper_parameter_tuning_jobs_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HyperParameterTuningJobSummaries = structure(list(structure(list(HyperParameterTuningJobName = structure(logical(0), tags = list(type = "string")), HyperParameterTuningJobArn = structure(logical(0), tags = list(type = "string")), HyperParameterTuningJobStatus = structure(logical(0), tags = list(type = "string")), Strategy = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), HyperParameterTuningEndTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), TrainingJobStatusCounters = structure(list(Completed = structure(logical(0), tags = list(type = "integer")), InProgress = structure(logical(0), tags = list(type = "integer")), RetryableError = structure(logical(0), tags = list(type = "integer")), NonRetryableError = structure(logical(0), tags = list(type = "integer")), Stopped = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), ObjectiveStatusCounters = structure(list(Succeeded = structure(logical(0), tags = list(type = "integer")), Pending = structure(logical(0), tags = list(type = "integer")), Failed = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), ResourceLimits = structure(list(MaxNumberOfTrainingJobs = structure(logical(0), tags = list(type = "integer")), MaxParallelTrainingJobs = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_image_versions_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), ImageName = structure(logical(0), tags = list(type = "string")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), MaxResults = structure(logical(0), tags = list(type = "integer")), NextToken = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_image_versions_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ImageVersions = structure(list(structure(list(CreationTime = structure(logical(0), tags = list(type = "timestamp")), FailureReason = structure(logical(0), tags = list(type = "string")), ImageArn = structure(logical(0), tags = list(type = "string")), ImageVersionArn = structure(logical(0), tags = list(type = "string")), ImageVersionStatus = structure(logical(0), tags = list(type = "string")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), Version = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_images_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_images_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Images = structure(list(structure(list(CreationTime = structure(logical(0), tags = list(type = "timestamp")), Description = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), ImageArn = structure(logical(0), tags = list(type = "string")), ImageName = structure(logical(0), tags = list(type = "string")), ImageStatus = structure(logical(0), tags = list(type = "string")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_labeling_jobs_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), MaxResults = structure(logical(0), tags = list(type = "integer")), NextToken = structure(logical(0), tags = list(type = "string")), NameContains = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), StatusEquals = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_labeling_jobs_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(LabelingJobSummaryList = structure(list(structure(list(LabelingJobName = structure(logical(0), tags = list(type = "string")), LabelingJobArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LabelingJobStatus = structure(logical(0), tags = list(type = "string")), LabelCounters = structure(list(TotalLabeled = structure(logical(0), tags = list(type = "integer")), HumanLabeled = structure(logical(0), tags = list(type = "integer")), MachineLabeled = structure(logical(0), tags = list(type = "integer")), FailedNonRetryableError = structure(logical(0), tags = list(type = "integer")), Unlabeled = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), WorkteamArn = structure(logical(0), tags = list(type = "string")), PreHumanTaskLambdaArn = structure(logical(0), tags = list(type = "string")), AnnotationConsolidationLambdaArn = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), LabelingJobOutput = structure(list(OutputDatasetS3Uri = structure(logical(0), tags = list(type = "string")), FinalActiveLearningModelArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), InputConfig = structure(list(DataSource = structure(list(S3DataSource = structure(list(ManifestS3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), SnsDataSource = structure(list(SnsTopicArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), DataAttributes = structure(list(ContentClassifiers = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_labeling_jobs_for_workteam_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(WorkteamArn = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), NextToken = structure(logical(0), tags = list(type = "string")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), JobReferenceCodeContains = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_labeling_jobs_for_workteam_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(LabelingJobSummaryList = structure(list(structure(list(LabelingJobName = structure(logical(0), tags = list(type = "string")), JobReferenceCode = structure(logical(0), tags = list(type = "string")), WorkRequesterAccountId = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LabelCounters = structure(list(HumanLabeled = structure(logical(0), tags = list(type = "integer")), PendingHuman = structure(logical(0), tags = list(type = "integer")), Total = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), NumberOfHumanWorkersPerDataObject = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_model_bias_job_definitions_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_model_bias_job_definitions_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionSummaries = structure(list(structure(list(MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringJobDefinitionArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), EndpointName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_model_explainability_job_definitions_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_model_explainability_job_definitions_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionSummaries = structure(list(structure(list(MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringJobDefinitionArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), EndpointName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_model_package_groups_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_model_package_groups_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageGroupSummaryList = structure(list(structure(list(ModelPackageGroupName = structure(logical(0), tags = list(type = "string")), ModelPackageGroupArn = structure(logical(0), tags = list(type = "string")), ModelPackageGroupDescription = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), ModelPackageGroupStatus = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_model_packages_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), ModelApprovalStatus = structure(logical(0), tags = list(type = "string")), ModelPackageGroupName = structure(logical(0), tags = list(type = "string")), ModelPackageType = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_model_packages_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageSummaryList = structure(list(structure(list(ModelPackageName = structure(logical(0), tags = list(type = "string")), ModelPackageGroupName = structure(logical(0), tags = list(type = "string")), ModelPackageVersion = structure(logical(0), tags = list(type = "integer")), ModelPackageArn = structure(logical(0), tags = list(type = "string")), ModelPackageDescription = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), ModelPackageStatus = structure(logical(0), tags = list(type = "string")), ModelApprovalStatus = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_model_quality_job_definitions_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_model_quality_job_definitions_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(JobDefinitionSummaries = structure(list(structure(list(MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringJobDefinitionArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), EndpointName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_models_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_models_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Models = structure(list(structure(list(ModelName = structure(logical(0), tags = list(type = "string")), ModelArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_monitoring_executions_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MonitoringScheduleName = structure(logical(0), tags = list(type = "string")), EndpointName = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), ScheduledTimeBefore = structure(logical(0), tags = list(type = "timestamp")), ScheduledTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), StatusEquals = structure(logical(0), tags = list(type = "string")), MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringTypeEquals = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_monitoring_executions_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MonitoringExecutionSummaries = structure(list(structure(list(MonitoringScheduleName = structure(logical(0), tags = list(type = "string")), ScheduledTime = structure(logical(0), tags = list(type = "timestamp")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), MonitoringExecutionStatus = structure(logical(0), tags = list(type = "string")), ProcessingJobArn = structure(logical(0), tags = list(type = "string")), EndpointName = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_monitoring_schedules_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), StatusEquals = structure(logical(0), tags = list(type = "string")), MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringTypeEquals = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_monitoring_schedules_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MonitoringScheduleSummaries = structure(list(structure(list(MonitoringScheduleName = structure(logical(0), tags = list(type = "string")), MonitoringScheduleArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), MonitoringScheduleStatus = structure(logical(0), tags = list(type = "string")), EndpointName = structure(logical(0), tags = list(type = "string")), MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_notebook_instance_lifecycle_configs_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NameContains = structure(logical(0), tags = list(type = "string")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_notebook_instance_lifecycle_configs_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), NotebookInstanceLifecycleConfigs = structure(list(structure(list(NotebookInstanceLifecycleConfigName = structure(logical(0), tags = list(type = "string")), NotebookInstanceLifecycleConfigArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_notebook_instances_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NameContains = structure(logical(0), tags = list(type = "string")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), StatusEquals = structure(logical(0), tags = list(type = "string")), NotebookInstanceLifecycleConfigNameContains = structure(logical(0), tags = list(type = "string")), DefaultCodeRepositoryContains = structure(logical(0), tags = list(type = "string")), AdditionalCodeRepositoryEquals = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_notebook_instances_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), NotebookInstances = structure(list(structure(list(NotebookInstanceName = structure(logical(0), tags = list(type = "string")), NotebookInstanceArn = structure(logical(0), tags = list(type = "string")), NotebookInstanceStatus = structure(logical(0), tags = list(type = "string")), Url = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), NotebookInstanceLifecycleConfigName = structure(logical(0), tags = list(type = "string")), DefaultCodeRepository = structure(logical(0), tags = list(type = "string")), AdditionalCodeRepositories = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_pipeline_execution_steps_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineExecutionArn = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_pipeline_execution_steps_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineExecutionSteps = structure(list(structure(list(StepName = structure(logical(0), tags = list(type = "string")), StartTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), StepStatus = structure(logical(0), tags = list(type = "string")), CacheHitResult = structure(list(SourcePipelineExecutionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), FailureReason = structure(logical(0), tags = list(type = "string")), Metadata = structure(list(TrainingJob = structure(list(Arn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ProcessingJob = structure(list(Arn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformJob = structure(list(Arn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Model = structure(list(Arn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), RegisterModel = structure(list(Arn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Condition = structure(list(Outcome = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_pipeline_executions_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineName = structure(logical(0), tags = list(type = "string")), CreatedAfter = structure(logical(0), tags = list(type = "timestamp")), CreatedBefore = structure(logical(0), tags = list(type = "timestamp")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_pipeline_executions_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineExecutionSummaries = structure(list(structure(list(PipelineExecutionArn = structure(logical(0), tags = list(type = "string")), StartTime = structure(logical(0), tags = list(type = "timestamp")), PipelineExecutionStatus = structure(logical(0), tags = list(type = "string")), PipelineExecutionDescription = structure(logical(0), tags = list(type = "string")), PipelineExecutionDisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_pipeline_parameters_for_execution_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineExecutionArn = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_pipeline_parameters_for_execution_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineParameters = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_pipelines_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineNamePrefix = structure(logical(0), tags = list(type = "string")), CreatedAfter = structure(logical(0), tags = list(type = "timestamp")), CreatedBefore = structure(logical(0), tags = list(type = "timestamp")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_pipelines_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineSummaries = structure(list(structure(list(PipelineArn = structure(logical(0), tags = list(type = "string")), PipelineName = structure(logical(0), tags = list(type = "string")), PipelineDisplayName = structure(logical(0), tags = list(type = "string")), PipelineDescription = structure(logical(0), tags = list(type = "string")), RoleArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastExecutionTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_processing_jobs_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), NameContains = structure(logical(0), tags = list(type = "string")), StatusEquals = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_processing_jobs_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ProcessingJobSummaries = structure(list(structure(list(ProcessingJobName = structure(logical(0), tags = list(type = "string")), ProcessingJobArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), ProcessingEndTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), ProcessingJobStatus = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), ExitMessage = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_projects_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), MaxResults = structure(logical(0), tags = list(type = "integer")), NameContains = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_projects_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ProjectSummaryList = structure(list(structure(list(ProjectName = structure(logical(0), tags = list(type = "string")), ProjectDescription = structure(logical(0), tags = list(type = "string")), ProjectArn = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), ProjectStatus = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_subscribed_workteams_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NameContains = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_subscribed_workteams_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SubscribedWorkteams = structure(list(structure(list(WorkteamArn = structure(logical(0), tags = list(type = "string")), MarketplaceTitle = structure(logical(0), tags = list(type = "string")), SellerName = structure(logical(0), tags = list(type = "string")), MarketplaceDescription = structure(logical(0), tags = list(type = "string")), ListingId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_tags_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ResourceArn = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_tags_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_training_jobs_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer")), CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), NameContains = structure(logical(0), tags = list(type = "string")), StatusEquals = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_training_jobs_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrainingJobSummaries = structure(list(structure(list(TrainingJobName = structure(logical(0), tags = list(type = "string")), TrainingJobArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), TrainingEndTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), TrainingJobStatus = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_training_jobs_for_hyper_parameter_tuning_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HyperParameterTuningJobName = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), StatusEquals = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_training_jobs_for_hyper_parameter_tuning_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrainingJobSummaries = structure(list(structure(list(TrainingJobDefinitionName = structure(logical(0), tags = list(type = "string")), TrainingJobName = structure(logical(0), tags = list(type = "string")), TrainingJobArn = structure(logical(0), tags = list(type = "string")), TuningJobName = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), TrainingStartTime = structure(logical(0), tags = list(type = "timestamp")), TrainingEndTime = structure(logical(0), tags = list(type = "timestamp")), TrainingJobStatus = structure(logical(0), tags = list(type = "string")), TunedHyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), FailureReason = structure(logical(0), tags = list(type = "string")), FinalHyperParameterTuningJobObjectiveMetric = structure(list(Type = structure(logical(0), tags = list(type = "string")), MetricName = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "float"))), tags = list(type = "structure")), ObjectiveStatus = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_transform_jobs_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CreationTimeAfter = structure(logical(0), tags = list(type = "timestamp")), CreationTimeBefore = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeAfter = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTimeBefore = structure(logical(0), tags = list(type = "timestamp")), NameContains = structure(logical(0), tags = list(type = "string")), StatusEquals = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_transform_jobs_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TransformJobSummaries = structure(list(structure(list(TransformJobName = structure(logical(0), tags = list(type = "string")), TransformJobArn = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), TransformEndTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), TransformJobStatus = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_trial_components_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string")), SourceArn = structure(logical(0), tags = list(type = "string")), CreatedAfter = structure(logical(0), tags = list(type = "timestamp")), CreatedBefore = structure(logical(0), tags = list(type = "timestamp")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_trial_components_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentSummaries = structure(list(structure(list(TrialComponentName = structure(logical(0), tags = list(type = "string")), TrialComponentArn = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), TrialComponentSource = structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Status = structure(list(PrimaryStatus = structure(logical(0), tags = list(type = "string")), Message = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StartTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_trials_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), TrialComponentName = structure(logical(0), tags = list(type = "string")), CreatedAfter = structure(logical(0), tags = list(type = "timestamp")), CreatedBefore = structure(logical(0), tags = list(type = "timestamp")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_trials_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialSummaries = structure(list(structure(list(TrialArn = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), TrialSource = structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_user_profiles_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(type = "integer")), SortOrder = structure(logical(0), tags = list(type = "string")), SortBy = structure(logical(0), tags = list(type = "string")), DomainIdEquals = structure(logical(0), tags = list(type = "string")), UserProfileNameContains = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_user_profiles_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(UserProfiles = structure(list(structure(list(DomainId = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_workforces_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NameContains = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_workforces_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Workforces = structure(list(structure(list(WorkforceName = structure(logical(0), tags = list(type = "string")), WorkforceArn = structure(logical(0), tags = list(type = "string")), LastUpdatedDate = structure(logical(0), tags = list(type = "timestamp")), SourceIpConfig = structure(list(Cidrs = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), SubDomain = structure(logical(0), tags = list(type = "string")), CognitoConfig = structure(list(UserPool = structure(logical(0), tags = list(type = "string")), ClientId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), OidcConfig = structure(list(ClientId = structure(logical(0), tags = list(type = "string")), Issuer = structure(logical(0), tags = list(type = "string")), AuthorizationEndpoint = structure(logical(0), tags = list(type = "string")), TokenEndpoint = structure(logical(0), tags = list(type = "string")), UserInfoEndpoint = structure(logical(0), tags = list(type = "string")), LogoutEndpoint = structure(logical(0), tags = list(type = "string")), JwksUri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CreateDate = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_workteams_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NameContains = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$list_workteams_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Workteams = structure(list(structure(list(WorkteamName = structure(logical(0), tags = list(type = "string")), MemberDefinitions = structure(list(structure(list(CognitoMemberDefinition = structure(list(UserPool = structure(logical(0), tags = list(type = "string")), UserGroup = structure(logical(0), tags = list(type = "string")), ClientId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), OidcMemberDefinition = structure(list(Groups = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), WorkteamArn = structure(logical(0), tags = list(type = "string")), WorkforceArn = structure(logical(0), tags = list(type = "string")), ProductListingIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Description = structure(logical(0), tags = list(type = "string")), SubDomain = structure(logical(0), tags = list(type = "string")), CreateDate = structure(logical(0), tags = list(type = "timestamp")), LastUpdatedDate = structure(logical(0), tags = list(type = "timestamp")), NotificationConfiguration = structure(list(NotificationTopicArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$put_model_package_group_policy_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageGroupName = structure(logical(0), tags = list(type = "string")), ResourcePolicy = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$put_model_package_group_policy_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageGroupArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$register_devices_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceFleetName = structure(logical(0), tags = list(type = "string")), Devices = structure(list(structure(list(DeviceName = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), IotThingName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$register_devices_output <- function(...) {
list()
}
.sagemaker$render_ui_template_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(UiTemplate = structure(list(Content = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Task = structure(list(Input = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), HumanTaskUiArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$render_ui_template_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(RenderedContent = structure(logical(0), tags = list(type = "string")), Errors = structure(list(structure(list(Code = structure(logical(0), tags = list(type = "string")), Message = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$search_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Resource = structure(logical(0), tags = list(type = "string")), SearchExpression = structure(list(Filters = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Operator = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), NestedFilters = structure(list(structure(list(NestedPropertyName = structure(logical(0), tags = list(type = "string")), Filters = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Operator = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "list")), SubExpressions = structure(list(structure(logical(0), tags = list(type = "structure"))), tags = list(type = "list")), Operator = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), SortBy = structure(logical(0), tags = list(type = "string")), SortOrder = structure(logical(0), tags = list(type = "string")), NextToken = structure(logical(0), tags = list(type = "string")), MaxResults = structure(logical(0), tags = list(box = TRUE, type = "integer"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$search_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Results = structure(list(structure(list(TrainingJob = structure(list(TrainingJobName = structure(logical(0), tags = list(type = "string")), TrainingJobArn = structure(logical(0), tags = list(type = "string")), TuningJobArn = structure(logical(0), tags = list(type = "string")), LabelingJobArn = structure(logical(0), tags = list(type = "string")), AutoMLJobArn = structure(logical(0), tags = list(type = "string")), ModelArtifacts = structure(list(S3ModelArtifacts = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TrainingJobStatus = structure(logical(0), tags = list(type = "string")), SecondaryStatus = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), HyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), AlgorithmSpecification = structure(list(TrainingImage = structure(logical(0), tags = list(type = "string")), AlgorithmName = structure(logical(0), tags = list(type = "string")), TrainingInputMode = structure(logical(0), tags = list(type = "string")), MetricDefinitions = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Regex = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), EnableSageMakerMetricsTimeSeries = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), InputDataConfig = structure(list(structure(list(ChannelName = structure(logical(0), tags = list(type = "string")), DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), AttributeNames = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), FileSystemDataSource = structure(list(FileSystemId = structure(logical(0), tags = list(type = "string")), FileSystemAccessMode = structure(logical(0), tags = list(type = "string")), FileSystemType = structure(logical(0), tags = list(type = "string")), DirectoryPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), RecordWrapperType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string")), ShuffleConfig = structure(list(Seed = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), OutputDataConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceConfig = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxWaitTimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), TrainingStartTime = structure(logical(0), tags = list(type = "timestamp")), TrainingEndTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), SecondaryStatusTransitions = structure(list(structure(list(Status = structure(logical(0), tags = list(type = "string")), StartTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), StatusMessage = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), FinalMetricDataList = structure(list(structure(list(MetricName = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "float")), Timestamp = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableManagedSpotTraining = structure(logical(0), tags = list(type = "boolean")), CheckpointConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TrainingTimeInSeconds = structure(logical(0), tags = list(type = "integer")), BillableTimeInSeconds = structure(logical(0), tags = list(type = "integer")), DebugHookConfig = structure(list(LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), HookParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), CollectionConfigurations = structure(list(structure(list(CollectionName = structure(logical(0), tags = list(type = "string")), CollectionParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ExperimentConfig = structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string")), TrialComponentDisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DebugRuleConfigurations = structure(list(structure(list(RuleConfigurationName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), RuleEvaluatorImage = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), RuleParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list")), TensorBoardOutputConfig = structure(list(LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DebugRuleEvaluationStatuses = structure(list(structure(list(RuleConfigurationName = structure(logical(0), tags = list(type = "string")), RuleEvaluationJobArn = structure(logical(0), tags = list(type = "string")), RuleEvaluationStatus = structure(logical(0), tags = list(type = "string")), StatusDetails = structure(logical(0), tags = list(type = "string")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), Experiment = structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), ExperimentArn = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Description = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), Trial = structure(list(TrialName = structure(logical(0), tags = list(type = "string")), TrialArn = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), ExperimentName = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), TrialComponentSummaries = structure(list(structure(list(TrialComponentName = structure(logical(0), tags = list(type = "string")), TrialComponentArn = structure(logical(0), tags = list(type = "string")), TrialComponentSource = structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), TrialComponent = structure(list(TrialComponentName = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), TrialComponentArn = structure(logical(0), tags = list(type = "string")), Source = structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), SourceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Status = structure(list(PrimaryStatus = structure(logical(0), tags = list(type = "string")), Message = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StartTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Parameters = structure(list(structure(list(StringValue = structure(logical(0), tags = list(type = "string")), NumberValue = structure(logical(0), tags = list(type = "double"))), tags = list(type = "structure"))), tags = list(type = "map")), InputArtifacts = structure(list(structure(list(MediaType = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "map")), OutputArtifacts = structure(list(structure(list(MediaType = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "map")), Metrics = structure(list(structure(list(MetricName = structure(logical(0), tags = list(type = "string")), SourceArn = structure(logical(0), tags = list(type = "string")), TimeStamp = structure(logical(0), tags = list(type = "timestamp")), Max = structure(logical(0), tags = list(type = "double")), Min = structure(logical(0), tags = list(type = "double")), Last = structure(logical(0), tags = list(type = "double")), Count = structure(logical(0), tags = list(type = "integer")), Avg = structure(logical(0), tags = list(type = "double")), StdDev = structure(logical(0), tags = list(type = "double"))), tags = list(type = "structure"))), tags = list(type = "list")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), SourceDetail = structure(list(SourceArn = structure(logical(0), tags = list(type = "string")), TrainingJob = structure(list(TrainingJobName = structure(logical(0), tags = list(type = "string")), TrainingJobArn = structure(logical(0), tags = list(type = "string")), TuningJobArn = structure(logical(0), tags = list(type = "string")), LabelingJobArn = structure(logical(0), tags = list(type = "string")), AutoMLJobArn = structure(logical(0), tags = list(type = "string")), ModelArtifacts = structure(list(S3ModelArtifacts = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TrainingJobStatus = structure(logical(0), tags = list(type = "string")), SecondaryStatus = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), HyperParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), AlgorithmSpecification = structure(list(TrainingImage = structure(logical(0), tags = list(type = "string")), AlgorithmName = structure(logical(0), tags = list(type = "string")), TrainingInputMode = structure(logical(0), tags = list(type = "string")), MetricDefinitions = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Regex = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), EnableSageMakerMetricsTimeSeries = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), InputDataConfig = structure(list(structure(list(ChannelName = structure(logical(0), tags = list(type = "string")), DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), AttributeNames = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), FileSystemDataSource = structure(list(FileSystemId = structure(logical(0), tags = list(type = "string")), FileSystemAccessMode = structure(logical(0), tags = list(type = "string")), FileSystemType = structure(logical(0), tags = list(type = "string")), DirectoryPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), RecordWrapperType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string")), ShuffleConfig = structure(list(Seed = structure(logical(0), tags = list(type = "long"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), OutputDataConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ResourceConfig = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer")), MaxWaitTimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), TrainingStartTime = structure(logical(0), tags = list(type = "timestamp")), TrainingEndTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), SecondaryStatusTransitions = structure(list(structure(list(Status = structure(logical(0), tags = list(type = "string")), StartTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), StatusMessage = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), FinalMetricDataList = structure(list(structure(list(MetricName = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "float")), Timestamp = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableManagedSpotTraining = structure(logical(0), tags = list(type = "boolean")), CheckpointConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TrainingTimeInSeconds = structure(logical(0), tags = list(type = "integer")), BillableTimeInSeconds = structure(logical(0), tags = list(type = "integer")), DebugHookConfig = structure(list(LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), HookParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), CollectionConfigurations = structure(list(structure(list(CollectionName = structure(logical(0), tags = list(type = "string")), CollectionParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ExperimentConfig = structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string")), TrialComponentDisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DebugRuleConfigurations = structure(list(structure(list(RuleConfigurationName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), RuleEvaluatorImage = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), RuleParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list")), TensorBoardOutputConfig = structure(list(LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DebugRuleEvaluationStatuses = structure(list(structure(list(RuleConfigurationName = structure(logical(0), tags = list(type = "string")), RuleEvaluationJobArn = structure(logical(0), tags = list(type = "string")), RuleEvaluationStatus = structure(logical(0), tags = list(type = "string")), StatusDetails = structure(logical(0), tags = list(type = "string")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ProcessingJob = structure(list(ProcessingInputs = structure(list(structure(list(InputName = structure(logical(0), tags = list(type = "string")), AppManaged = structure(logical(0), tags = list(type = "boolean")), S3Input = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3DataType = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), S3CompressionType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DatasetDefinition = structure(list(AthenaDatasetDefinition = structure(list(Catalog = structure(logical(0), tags = list(type = "string")), Database = structure(logical(0), tags = list(type = "string")), QueryString = structure(logical(0), tags = list(type = "string")), WorkGroup = structure(logical(0), tags = list(type = "string")), OutputS3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string")), OutputFormat = structure(logical(0), tags = list(type = "string")), OutputCompression = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), RedshiftDatasetDefinition = structure(list(ClusterId = structure(logical(0), tags = list(type = "string")), Database = structure(logical(0), tags = list(type = "string")), DbUser = structure(logical(0), tags = list(type = "string")), QueryString = structure(logical(0), tags = list(type = "string")), ClusterRoleArn = structure(logical(0), tags = list(type = "string")), OutputS3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string")), OutputFormat = structure(logical(0), tags = list(type = "string")), OutputCompression = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LocalPath = structure(logical(0), tags = list(type = "string")), DataDistributionType = structure(logical(0), tags = list(type = "string")), InputMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), ProcessingOutputConfig = structure(list(Outputs = structure(list(structure(list(OutputName = structure(logical(0), tags = list(type = "string")), S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), FeatureStoreOutput = structure(list(FeatureGroupName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), AppManaged = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ProcessingJobName = structure(logical(0), tags = list(type = "string")), ProcessingResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), AppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ContainerEntrypoint = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), ContainerArguments = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), ExperimentConfig = structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string")), TrialComponentDisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ProcessingJobArn = structure(logical(0), tags = list(type = "string")), ProcessingJobStatus = structure(logical(0), tags = list(type = "string")), ExitMessage = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), ProcessingEndTime = structure(logical(0), tags = list(type = "timestamp")), ProcessingStartTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), MonitoringScheduleArn = structure(logical(0), tags = list(type = "string")), AutoMLJobArn = structure(logical(0), tags = list(type = "string")), TrainingJobArn = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), TransformJob = structure(list(TransformJobName = structure(logical(0), tags = list(type = "string")), TransformJobArn = structure(logical(0), tags = list(type = "string")), TransformJobStatus = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), ModelName = structure(logical(0), tags = list(type = "string")), MaxConcurrentTransforms = structure(logical(0), tags = list(type = "integer")), ModelClientConfig = structure(list(InvocationsTimeoutInSeconds = structure(logical(0), tags = list(type = "integer")), InvocationsMaxRetries = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), MaxPayloadInMB = structure(logical(0), tags = list(type = "integer")), BatchStrategy = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), TransformInput = structure(list(DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), SplitType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformOutput = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), Accept = structure(logical(0), tags = list(type = "string")), AssembleWith = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformResources = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), TransformStartTime = structure(logical(0), tags = list(type = "timestamp")), TransformEndTime = structure(logical(0), tags = list(type = "timestamp")), LabelingJobArn = structure(logical(0), tags = list(type = "string")), AutoMLJobArn = structure(logical(0), tags = list(type = "string")), DataProcessing = structure(list(InputFilter = structure(logical(0), tags = list(type = "string")), OutputFilter = structure(logical(0), tags = list(type = "string")), JoinSource = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ExperimentConfig = structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), TrialName = structure(logical(0), tags = list(type = "string")), TrialComponentDisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), Parents = structure(list(structure(list(TrialName = structure(logical(0), tags = list(type = "string")), ExperimentName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), Endpoint = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), EndpointArn = structure(logical(0), tags = list(type = "string")), EndpointConfigName = structure(logical(0), tags = list(type = "string")), ProductionVariants = structure(list(structure(list(VariantName = structure(logical(0), tags = list(type = "string")), DeployedImages = structure(list(structure(list(SpecifiedImage = structure(logical(0), tags = list(type = "string")), ResolvedImage = structure(logical(0), tags = list(type = "string")), ResolutionTime = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "list")), CurrentWeight = structure(logical(0), tags = list(type = "float")), DesiredWeight = structure(logical(0), tags = list(type = "float")), CurrentInstanceCount = structure(logical(0), tags = list(type = "integer")), DesiredInstanceCount = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "list")), DataCaptureConfig = structure(list(EnableCapture = structure(logical(0), tags = list(type = "boolean")), CaptureStatus = structure(logical(0), tags = list(type = "string")), CurrentSamplingPercentage = structure(logical(0), tags = list(type = "integer")), DestinationS3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), EndpointStatus = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), MonitoringSchedules = structure(list(structure(list(MonitoringScheduleArn = structure(logical(0), tags = list(type = "string")), MonitoringScheduleName = structure(logical(0), tags = list(type = "string")), MonitoringScheduleStatus = structure(logical(0), tags = list(type = "string")), MonitoringType = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), MonitoringScheduleConfig = structure(list(ScheduleConfig = structure(list(ScheduleExpression = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MonitoringJobDefinition = structure(list(BaselineConfig = structure(list(BaseliningJobName = structure(logical(0), tags = list(type = "string")), ConstraintsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StatisticsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), MonitoringInputs = structure(list(structure(list(EndpointInput = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), FeaturesAttribute = structure(logical(0), tags = list(type = "string")), InferenceAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityThresholdAttribute = structure(logical(0), tags = list(type = "double")), StartTimeOffset = structure(logical(0), tags = list(type = "string")), EndTimeOffset = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), MonitoringOutputConfig = structure(list(MonitoringOutputs = structure(list(structure(list(S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MonitoringResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), MonitoringAppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ContainerEntrypoint = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), ContainerArguments = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), RecordPreprocessorSourceUri = structure(logical(0), tags = list(type = "string")), PostAnalyticsProcessorSourceUri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), EndpointName = structure(logical(0), tags = list(type = "string")), LastMonitoringExecutionSummary = structure(list(MonitoringScheduleName = structure(logical(0), tags = list(type = "string")), ScheduledTime = structure(logical(0), tags = list(type = "timestamp")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), MonitoringExecutionStatus = structure(logical(0), tags = list(type = "string")), ProcessingJobArn = structure(logical(0), tags = list(type = "string")), EndpointName = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string")), MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "list")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ModelPackage = structure(list(ModelPackageName = structure(logical(0), tags = list(type = "string")), ModelPackageGroupName = structure(logical(0), tags = list(type = "string")), ModelPackageVersion = structure(logical(0), tags = list(type = "integer")), ModelPackageArn = structure(logical(0), tags = list(type = "string")), ModelPackageDescription = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), InferenceSpecification = structure(list(Containers = structure(list(structure(list(ContainerHostname = structure(logical(0), tags = list(type = "string")), Image = structure(logical(0), tags = list(type = "string")), ImageDigest = structure(logical(0), tags = list(type = "string")), ModelDataUrl = structure(logical(0), tags = list(type = "string")), ProductId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), SupportedTransformInstanceTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedRealtimeInferenceInstanceTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedContentTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SupportedResponseMIMETypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), SourceAlgorithmSpecification = structure(list(SourceAlgorithms = structure(list(structure(list(ModelDataUrl = structure(logical(0), tags = list(type = "string")), AlgorithmName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ValidationSpecification = structure(list(ValidationRole = structure(logical(0), tags = list(type = "string")), ValidationProfiles = structure(list(structure(list(ProfileName = structure(logical(0), tags = list(type = "string")), TransformJobDefinition = structure(list(MaxConcurrentTransforms = structure(logical(0), tags = list(type = "integer")), MaxPayloadInMB = structure(logical(0), tags = list(type = "integer")), BatchStrategy = structure(logical(0), tags = list(type = "string")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), TransformInput = structure(list(DataSource = structure(list(S3DataSource = structure(list(S3DataType = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ContentType = structure(logical(0), tags = list(type = "string")), CompressionType = structure(logical(0), tags = list(type = "string")), SplitType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformOutput = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), Accept = structure(logical(0), tags = list(type = "string")), AssembleWith = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), TransformResources = structure(list(InstanceType = structure(logical(0), tags = list(type = "string")), InstanceCount = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ModelPackageStatus = structure(logical(0), tags = list(type = "string")), ModelPackageStatusDetails = structure(list(ValidationStatuses = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), ImageScanStatuses = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), FailureReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), CertifyForMarketplace = structure(logical(0), tags = list(type = "boolean")), ModelApprovalStatus = structure(logical(0), tags = list(type = "string")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MetadataProperties = structure(list(CommitId = structure(logical(0), tags = list(type = "string")), Repository = structure(logical(0), tags = list(type = "string")), GeneratedBy = structure(logical(0), tags = list(type = "string")), ProjectId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ModelMetrics = structure(list(ModelQuality = structure(list(Statistics = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Constraints = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), ModelDataQuality = structure(list(Statistics = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Constraints = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), Bias = structure(list(Report = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), Explainability = structure(list(Report = structure(list(ContentType = structure(logical(0), tags = list(type = "string")), ContentDigest = structure(logical(0), tags = list(type = "string")), S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ApprovalDescription = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), ModelPackageGroup = structure(list(ModelPackageGroupName = structure(logical(0), tags = list(type = "string")), ModelPackageGroupArn = structure(logical(0), tags = list(type = "string")), ModelPackageGroupDescription = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), ModelPackageGroupStatus = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), Pipeline = structure(list(PipelineArn = structure(logical(0), tags = list(type = "string")), PipelineName = structure(logical(0), tags = list(type = "string")), PipelineDisplayName = structure(logical(0), tags = list(type = "string")), PipelineDescription = structure(logical(0), tags = list(type = "string")), RoleArn = structure(logical(0), tags = list(type = "string")), PipelineStatus = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), LastRunTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), PipelineExecution = structure(list(PipelineArn = structure(logical(0), tags = list(type = "string")), PipelineExecutionArn = structure(logical(0), tags = list(type = "string")), PipelineExecutionDisplayName = structure(logical(0), tags = list(type = "string")), PipelineExecutionStatus = structure(logical(0), tags = list(type = "string")), PipelineExecutionDescription = structure(logical(0), tags = list(type = "string")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), LastModifiedTime = structure(logical(0), tags = list(type = "timestamp")), CreatedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), LastModifiedBy = structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), DomainId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), PipelineParameters = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), FeatureGroup = structure(list(FeatureGroupArn = structure(logical(0), tags = list(type = "string")), FeatureGroupName = structure(logical(0), tags = list(type = "string")), RecordIdentifierFeatureName = structure(logical(0), tags = list(type = "string")), EventTimeFeatureName = structure(logical(0), tags = list(type = "string")), FeatureDefinitions = structure(list(structure(list(FeatureName = structure(logical(0), tags = list(type = "string")), FeatureType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), CreationTime = structure(logical(0), tags = list(type = "timestamp")), OnlineStoreConfig = structure(list(SecurityConfig = structure(list(KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), EnableOnlineStore = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure")), OfflineStoreConfig = structure(list(S3StorageConfig = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), DisableGlueTableCreation = structure(logical(0), tags = list(type = "boolean")), DataCatalogConfig = structure(list(TableName = structure(logical(0), tags = list(type = "string")), Catalog = structure(logical(0), tags = list(type = "string")), Database = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string")), FeatureGroupStatus = structure(logical(0), tags = list(type = "string")), OfflineStoreStatus = structure(list(Status = structure(logical(0), tags = list(type = "string")), BlockedReason = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), FailureReason = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), Tags = structure(list(structure(list(Key = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), NextToken = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$start_monitoring_schedule_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MonitoringScheduleName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$start_monitoring_schedule_output <- function(...) {
list()
}
.sagemaker$start_notebook_instance_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$start_notebook_instance_output <- function(...) {
list()
}
.sagemaker$start_pipeline_execution_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineName = structure(logical(0), tags = list(type = "string")), PipelineExecutionDisplayName = structure(logical(0), tags = list(type = "string")), PipelineParameters = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), PipelineExecutionDescription = structure(logical(0), tags = list(type = "string")), ClientRequestToken = structure(logical(0), tags = list(idempotencyToken = TRUE, type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$start_pipeline_execution_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineExecutionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_auto_ml_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AutoMLJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_auto_ml_job_output <- function(...) {
list()
}
.sagemaker$stop_compilation_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CompilationJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_compilation_job_output <- function(...) {
list()
}
.sagemaker$stop_edge_packaging_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EdgePackagingJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_edge_packaging_job_output <- function(...) {
list()
}
.sagemaker$stop_hyper_parameter_tuning_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(HyperParameterTuningJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_hyper_parameter_tuning_job_output <- function(...) {
list()
}
.sagemaker$stop_labeling_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(LabelingJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_labeling_job_output <- function(...) {
list()
}
.sagemaker$stop_monitoring_schedule_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MonitoringScheduleName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_monitoring_schedule_output <- function(...) {
list()
}
.sagemaker$stop_notebook_instance_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_notebook_instance_output <- function(...) {
list()
}
.sagemaker$stop_pipeline_execution_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineExecutionArn = structure(logical(0), tags = list(type = "string")), ClientRequestToken = structure(logical(0), tags = list(idempotencyToken = TRUE, type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_pipeline_execution_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineExecutionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_processing_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ProcessingJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_processing_job_output <- function(...) {
list()
}
.sagemaker$stop_training_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrainingJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_training_job_output <- function(...) {
list()
}
.sagemaker$stop_transform_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TransformJobName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$stop_transform_job_output <- function(...) {
list()
}
.sagemaker$update_action_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ActionName = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), Status = structure(logical(0), tags = list(type = "string")), Properties = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), PropertiesToRemove = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_action_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ActionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_app_image_config_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AppImageConfigName = structure(logical(0), tags = list(type = "string")), KernelGatewayImageConfig = structure(list(KernelSpecs = structure(list(structure(list(Name = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), FileSystemConfig = structure(list(MountPath = structure(logical(0), tags = list(type = "string")), DefaultUid = structure(logical(0), tags = list(box = TRUE, type = "integer")), DefaultGid = structure(logical(0), tags = list(box = TRUE, type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_app_image_config_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(AppImageConfigArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_artifact_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ArtifactArn = structure(logical(0), tags = list(type = "string")), ArtifactName = structure(logical(0), tags = list(type = "string")), Properties = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), PropertiesToRemove = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_artifact_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ArtifactArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_code_repository_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CodeRepositoryName = structure(logical(0), tags = list(type = "string")), GitConfig = structure(list(SecretArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_code_repository_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(CodeRepositoryArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_context_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ContextName = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), Properties = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), PropertiesToRemove = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_context_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ContextArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_device_fleet_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceFleetName = structure(logical(0), tags = list(type = "string")), RoleArn = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), OutputConfig = structure(list(S3OutputLocation = structure(logical(0), tags = list(type = "string")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_device_fleet_output <- function(...) {
list()
}
.sagemaker$update_devices_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeviceFleetName = structure(logical(0), tags = list(type = "string")), Devices = structure(list(structure(list(DeviceName = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string")), IotThingName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_devices_output <- function(...) {
list()
}
.sagemaker$update_domain_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainId = structure(logical(0), tags = list(type = "string")), DefaultUserSettings = structure(list(ExecutionRole = structure(logical(0), tags = list(type = "string")), SecurityGroups = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SharingSettings = structure(list(NotebookOutputOption = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), S3KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JupyterServerAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), KernelGatewayAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CustomImages = structure(list(structure(list(ImageName = structure(logical(0), tags = list(type = "string")), ImageVersionNumber = structure(logical(0), tags = list(box = TRUE, type = "integer")), AppImageConfigName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), TensorBoardAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_domain_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_endpoint_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), EndpointConfigName = structure(logical(0), tags = list(type = "string")), RetainAllVariantProperties = structure(logical(0), tags = list(type = "boolean")), ExcludeRetainedVariantProperties = structure(list(structure(list(VariantPropertyType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), DeploymentConfig = structure(list(BlueGreenUpdatePolicy = structure(list(TrafficRoutingConfiguration = structure(list(Type = structure(logical(0), tags = list(type = "string")), WaitIntervalInSeconds = structure(logical(0), tags = list(type = "integer")), CanarySize = structure(list(Type = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "structure")), TerminationWaitInSeconds = structure(logical(0), tags = list(type = "integer")), MaximumExecutionTimeoutInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), AutoRollbackConfiguration = structure(list(Alarms = structure(list(structure(list(AlarmName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_endpoint_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_endpoint_weights_and_capacities_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), DesiredWeightsAndCapacities = structure(list(structure(list(VariantName = structure(logical(0), tags = list(type = "string")), DesiredWeight = structure(logical(0), tags = list(type = "float")), DesiredInstanceCount = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_endpoint_weights_and_capacities_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(EndpointArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_experiment_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ExperimentName = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), Description = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_experiment_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ExperimentArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_image_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DeleteProperties = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Description = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), ImageName = structure(logical(0), tags = list(type = "string")), RoleArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_image_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ImageArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_model_package_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageArn = structure(logical(0), tags = list(type = "string")), ModelApprovalStatus = structure(logical(0), tags = list(type = "string")), ApprovalDescription = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_model_package_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(ModelPackageArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_monitoring_schedule_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MonitoringScheduleName = structure(logical(0), tags = list(type = "string")), MonitoringScheduleConfig = structure(list(ScheduleConfig = structure(list(ScheduleExpression = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MonitoringJobDefinition = structure(list(BaselineConfig = structure(list(BaseliningJobName = structure(logical(0), tags = list(type = "string")), ConstraintsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StatisticsResource = structure(list(S3Uri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), MonitoringInputs = structure(list(structure(list(EndpointInput = structure(list(EndpointName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3InputMode = structure(logical(0), tags = list(type = "string")), S3DataDistributionType = structure(logical(0), tags = list(type = "string")), FeaturesAttribute = structure(logical(0), tags = list(type = "string")), InferenceAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityAttribute = structure(logical(0), tags = list(type = "string")), ProbabilityThresholdAttribute = structure(logical(0), tags = list(type = "double")), StartTimeOffset = structure(logical(0), tags = list(type = "string")), EndTimeOffset = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), MonitoringOutputConfig = structure(list(MonitoringOutputs = structure(list(structure(list(S3Output = structure(list(S3Uri = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3UploadMode = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MonitoringResources = structure(list(ClusterConfig = structure(list(InstanceCount = structure(logical(0), tags = list(type = "integer")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), VolumeKmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), MonitoringAppSpecification = structure(list(ImageUri = structure(logical(0), tags = list(type = "string")), ContainerEntrypoint = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), ContainerArguments = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), RecordPreprocessorSourceUri = structure(logical(0), tags = list(type = "string")), PostAnalyticsProcessorSourceUri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StoppingCondition = structure(list(MaxRuntimeInSeconds = structure(logical(0), tags = list(type = "integer"))), tags = list(type = "structure")), Environment = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), NetworkConfig = structure(list(EnableInterContainerTrafficEncryption = structure(logical(0), tags = list(type = "boolean")), EnableNetworkIsolation = structure(logical(0), tags = list(type = "boolean")), VpcConfig = structure(list(SecurityGroupIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Subnets = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure")), RoleArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), MonitoringJobDefinitionName = structure(logical(0), tags = list(type = "string")), MonitoringType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_monitoring_schedule_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(MonitoringScheduleArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_notebook_instance_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceName = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string")), RoleArn = structure(logical(0), tags = list(type = "string")), LifecycleConfigName = structure(logical(0), tags = list(type = "string")), DisassociateLifecycleConfig = structure(logical(0), tags = list(type = "boolean")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), DefaultCodeRepository = structure(logical(0), tags = list(type = "string")), AdditionalCodeRepositories = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), AcceleratorTypes = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), DisassociateAcceleratorTypes = structure(logical(0), tags = list(type = "boolean")), DisassociateDefaultCodeRepository = structure(logical(0), tags = list(type = "boolean")), DisassociateAdditionalCodeRepositories = structure(logical(0), tags = list(type = "boolean")), RootAccess = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_notebook_instance_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_notebook_instance_lifecycle_config_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(NotebookInstanceLifecycleConfigName = structure(logical(0), tags = list(type = "string")), OnCreate = structure(list(structure(list(Content = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list")), OnStart = structure(list(structure(list(Content = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_notebook_instance_lifecycle_config_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_pipeline_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineName = structure(logical(0), tags = list(type = "string")), PipelineDisplayName = structure(logical(0), tags = list(type = "string")), PipelineDefinition = structure(logical(0), tags = list(type = "string")), PipelineDescription = structure(logical(0), tags = list(type = "string")), RoleArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_pipeline_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_pipeline_execution_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineExecutionArn = structure(logical(0), tags = list(type = "string")), PipelineExecutionDescription = structure(logical(0), tags = list(type = "string")), PipelineExecutionDisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_pipeline_execution_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(PipelineExecutionArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_training_job_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrainingJobName = structure(logical(0), tags = list(type = "string")), ProfilerConfig = structure(list(S3OutputPath = structure(logical(0), tags = list(type = "string")), ProfilingIntervalInMilliseconds = structure(logical(0), tags = list(type = "long")), ProfilingParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map")), DisableProfiler = structure(logical(0), tags = list(type = "boolean"))), tags = list(type = "structure")), ProfilerRuleConfigurations = structure(list(structure(list(RuleConfigurationName = structure(logical(0), tags = list(type = "string")), LocalPath = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), RuleEvaluatorImage = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string")), VolumeSizeInGB = structure(logical(0), tags = list(type = "integer")), RuleParameters = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "map"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_training_job_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrainingJobArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_trial_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialName = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_trial_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_trial_component_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentName = structure(logical(0), tags = list(type = "string")), DisplayName = structure(logical(0), tags = list(type = "string")), Status = structure(list(PrimaryStatus = structure(logical(0), tags = list(type = "string")), Message = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), StartTime = structure(logical(0), tags = list(type = "timestamp")), EndTime = structure(logical(0), tags = list(type = "timestamp")), Parameters = structure(list(structure(list(StringValue = structure(logical(0), tags = list(type = "string")), NumberValue = structure(logical(0), tags = list(type = "double"))), tags = list(type = "structure"))), tags = list(type = "map")), ParametersToRemove = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), InputArtifacts = structure(list(structure(list(MediaType = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "map")), InputArtifactsToRemove = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), OutputArtifacts = structure(list(structure(list(MediaType = structure(logical(0), tags = list(type = "string")), Value = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "map")), OutputArtifactsToRemove = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_trial_component_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(TrialComponentArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_user_profile_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(DomainId = structure(logical(0), tags = list(type = "string")), UserProfileName = structure(logical(0), tags = list(type = "string")), UserSettings = structure(list(ExecutionRole = structure(logical(0), tags = list(type = "string")), SecurityGroups = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), SharingSettings = structure(list(NotebookOutputOption = structure(logical(0), tags = list(type = "string")), S3OutputPath = structure(logical(0), tags = list(type = "string")), S3KmsKeyId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), JupyterServerAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure")), KernelGatewayAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CustomImages = structure(list(structure(list(ImageName = structure(logical(0), tags = list(type = "string")), ImageVersionNumber = structure(logical(0), tags = list(box = TRUE, type = "integer")), AppImageConfigName = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "list"))), tags = list(type = "structure")), TensorBoardAppSettings = structure(list(DefaultResourceSpec = structure(list(SageMakerImageArn = structure(logical(0), tags = list(type = "string")), SageMakerImageVersionArn = structure(logical(0), tags = list(type = "string")), InstanceType = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_user_profile_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(UserProfileArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_workforce_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(WorkforceName = structure(logical(0), tags = list(type = "string")), SourceIpConfig = structure(list(Cidrs = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), OidcConfig = structure(list(ClientId = structure(logical(0), tags = list(type = "string")), ClientSecret = structure(logical(0), tags = list(type = "string", sensitive = TRUE)), Issuer = structure(logical(0), tags = list(type = "string")), AuthorizationEndpoint = structure(logical(0), tags = list(type = "string")), TokenEndpoint = structure(logical(0), tags = list(type = "string")), UserInfoEndpoint = structure(logical(0), tags = list(type = "string")), LogoutEndpoint = structure(logical(0), tags = list(type = "string")), JwksUri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_workforce_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Workforce = structure(list(WorkforceName = structure(logical(0), tags = list(type = "string")), WorkforceArn = structure(logical(0), tags = list(type = "string")), LastUpdatedDate = structure(logical(0), tags = list(type = "timestamp")), SourceIpConfig = structure(list(Cidrs = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure")), SubDomain = structure(logical(0), tags = list(type = "string")), CognitoConfig = structure(list(UserPool = structure(logical(0), tags = list(type = "string")), ClientId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), OidcConfig = structure(list(ClientId = structure(logical(0), tags = list(type = "string")), Issuer = structure(logical(0), tags = list(type = "string")), AuthorizationEndpoint = structure(logical(0), tags = list(type = "string")), TokenEndpoint = structure(logical(0), tags = list(type = "string")), UserInfoEndpoint = structure(logical(0), tags = list(type = "string")), LogoutEndpoint = structure(logical(0), tags = list(type = "string")), JwksUri = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), CreateDate = structure(logical(0), tags = list(type = "timestamp"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_workteam_input <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(WorkteamName = structure(logical(0), tags = list(type = "string")), MemberDefinitions = structure(list(structure(list(CognitoMemberDefinition = structure(list(UserPool = structure(logical(0), tags = list(type = "string")), UserGroup = structure(logical(0), tags = list(type = "string")), ClientId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), OidcMemberDefinition = structure(list(Groups = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), Description = structure(logical(0), tags = list(type = "string")), NotificationConfiguration = structure(list(NotificationTopicArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
}
.sagemaker$update_workteam_output <- function(...) {
args <- c(as.list(environment()), list(...))
shape <- structure(list(Workteam = structure(list(WorkteamName = structure(logical(0), tags = list(type = "string")), MemberDefinitions = structure(list(structure(list(CognitoMemberDefinition = structure(list(UserPool = structure(logical(0), tags = list(type = "string")), UserGroup = structure(logical(0), tags = list(type = "string")), ClientId = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure")), OidcMemberDefinition = structure(list(Groups = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "list")), WorkteamArn = structure(logical(0), tags = list(type = "string")), WorkforceArn = structure(logical(0), tags = list(type = "string")), ProductListingIds = structure(list(structure(logical(0), tags = list(type = "string"))), tags = list(type = "list")), Description = structure(logical(0), tags = list(type = "string")), SubDomain = structure(logical(0), tags = list(type = "string")), CreateDate = structure(logical(0), tags = list(type = "timestamp")), LastUpdatedDate = structure(logical(0), tags = list(type = "timestamp")), NotificationConfiguration = structure(list(NotificationTopicArn = structure(logical(0), tags = list(type = "string"))), tags = list(type = "structure"))), tags = list(type = "structure"))), tags = list(type = "structure"))
return(populate(args, shape))
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.