# AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _align as align
from torch import device, empty_strided
from torch._inductor.async_compile import AsyncCompile
from torch._inductor.select_algorithm import extern_kernels
from torch._inductor.codegen.multi_kernel import MultiKernelCall
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid, split_scan_grid, grid_combo_kernels, start_graph, end_graph
from torch._C import _cuda_getCurrentRawStream as get_raw_stream

aten = torch.ops.aten
inductor_ops = torch.ops.inductor
_quantized = torch.ops._quantized
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cpu = torch._C._dynamo.guards._empty_strided_cpu
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
empty_strided_xpu = torch._C._dynamo.guards._empty_strided_xpu
reinterpret_tensor = torch._C._dynamo.guards._reinterpret_tensor
alloc_from_pool = torch.ops.inductor._alloc_from_pool
async_compile = AsyncCompile()


# kernel path: runs/run_shard_7/inductor_cache/yx/cyxb666ynzj6hs5gae7urh4vogf33xat7au3chs77wng6jre6ejs.py
# Topologically Sorted Source Nodes: [t_1, t_2], Original ATen: [aten.mul, aten.sum]
# Source node to ATen node mapping:
#   t_1 => mul
#   t_2 => sum_1
# Graph fragment:
#   %mul : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%primals_1, %primals_2), kwargs = {})
#   %sum_1 : [num_users=1] = call_function[target=torch.ops.aten.sum.dim_IntList](args = (%mul, [1]), kwargs = {})
triton_poi_fused_mul_sum_0 = async_compile.triton('triton_poi_fused_mul_sum_0', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[64], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_mul_sum_0', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 5, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_mul_sum_0(in_ptr0, in_ptr1, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 64
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x2 = (xindex // 16)
    x3 = xindex % 16
    x0 = xindex % 4
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (x3 + (64*x2)), xmask)
    tmp1 = tl.load(in_ptr1 + (x0), xmask, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr0 + (16 + x3 + (64*x2)), xmask)
    tmp6 = tl.load(in_ptr0 + (32 + x3 + (64*x2)), xmask)
    tmp9 = tl.load(in_ptr0 + (48 + x3 + (64*x2)), xmask)
    tmp2 = tmp0 * tmp1
    tmp4 = tmp3 * tmp1
    tmp5 = tmp2 + tmp4
    tmp7 = tmp6 * tmp1
    tmp8 = tmp5 + tmp7
    tmp10 = tmp9 * tmp1
    tmp11 = tmp8 + tmp10
    tl.store(out_ptr0 + (x4), tmp11, xmask)
''', device_str='cuda')


async_compile.wait(globals())
del async_compile

def call(args):
    primals_1, primals_2 = args
    args.clear()
    assert_size_stride(primals_1, (4, 4, 4, 4), (64, 16, 4, 1))
    assert_size_stride(primals_2, (4, ), (1, ))
    with torch.cuda._DeviceGuard(0):
        torch.cuda.set_device(0)
        buf0 = empty_strided_cuda((4, 4, 4), (16, 4, 1), torch.float32)
        # Topologically Sorted Source Nodes: [t_1, t_2], Original ATen: [aten.mul, aten.sum]
        stream0 = get_raw_stream(0)
        triton_poi_fused_mul_sum_0.run(primals_1, primals_2, buf0, 64, grid=grid(64), stream=stream0)
        del primals_2
    return (buf0, primals_1, )


def benchmark_compiled_module(times=10, repeat=10):
    from torch._dynamo.testing import rand_strided
    from torch._inductor.utils import print_performance
    primals_1 = rand_strided((4, 4, 4, 4), (64, 16, 4, 1), device='cuda:0', dtype=torch.float32)
    primals_2 = rand_strided((4, ), (1, ), device='cuda:0', dtype=torch.float32)
    fn = lambda: call([primals_1, primals_2])
    return print_performance(fn, times=times, repeat=repeat)


if __name__ == "__main__":
    from torch._inductor.wrapper_benchmark import compiled_module_main
    compiled_module_main('None', benchmark_compiled_module)

import torch
import numpy as np
from torch import nn
from torch.utils.data import DataLoader
from torchvision import transforms
from sklearn.preprocessing import StandardScaler
from sklearn import metrics
from torch.utils.data import Dataset


def compute_auc(labels, scores, pos_label=1):
    fpr, tpr, _thresholds = metrics.roc_curve(labels, scores, pos_label=
        pos_label)
    return metrics.auc(fpr, tpr)


class Subset(Dataset):

    def __init__(self, data, labels, normalize=False):
        self.ims = data
        self.labels = labels
        self.normalize = normalize
        if normalize:
            self.T = transforms.Normalize(0.5, 0.5)
        else:
            self.T = lambda x: x

    def __getitem__(self, idx):
        ret = {'ims': self.T(self.ims[idx]), 'labels': self.labels[idx]}
        return ret

    def __len__(self):
        return self.labels.shape[0]


class RobustLogisticRegression(nn.Module):

    def __init__(self, alpha=[1.0, 1.0, 1.0, 1.0], beta=1.0, alpha0=[1.0, 
        0.0, 0.0, 0.0]):
        super(RobustLogisticRegression, self).__init__()
        self.alpha = nn.Parameter(torch.Tensor(alpha))
        if not len(alpha0) == 4:
            raise ValueError('alpha0 must be a vector og length 4')
        self.alpha0 = torch.Tensor(alpha0)
        self.beta = beta
        self.scaler = StandardScaler()

    def get_alpha(self):
        return self.alpha

    def forward(self, x):
        t = torch.Tensor(x)
        t = t * self.get_alpha()
        t = t.sum(1)
        return t

    def predict_prob(self, x):
        return 1 / (1 + torch.exp(-self(x)))

    def predict(self, x):
        return torch.round(self.predict_prob(x))

    def prior_loss(self):
        return self.beta * torch.sqrt(torch.square(self.alpha0 - self.alpha
            ).sum())

    def binary_acc(self, x, y):
        y_true = np.array(y)
        y_pred = self.predict(x).detach().numpy()
        nhits = (y_pred == y_true).sum()
        return nhits / y_true.shape[0]

    def auc(self, x, y):
        scores = self.predict_prob(x)
        return compute_auc(y, scores.detach().numpy())

    def scaler_fit(self, x):
        self.scaler.fit(x)

    def scaler_transform(self, x):
        return self.scaler.transform(x)

    def save_weights(self, f):
        np.save(f, self.alpha_params.detach().numpy())

    def fit(self, x, y, tst_x=None, tst_y=None, nepochs=2, batch_size=256,
        lr=0.01, opt_type='lbfgs', workers=1, balanced=True, verb=True,
        scale=False, early_stopping=False, patience=10):
        if scale:
            self.scaler_fit(x)
            x = self.scaler_transform(x)
            tst_x = tst_x if tst_x is None else self.scaler_transform(tst_x)
        if balanced:
            n1 = int(sum(y))
            n0 = len(y) - n1
            if n0 < n1:
                p = int(np.floor(n1 / n0))
                X = np.concatenate((x[y == 0].repeat(p, 0), x[y == 1]), 0)
                Y = np.concatenate((y[y == 0].repeat(p, 0), y[y == 1]), 0)
            else:
                p = int(np.floor(n0 / n1))
                X = np.concatenate((x[y == 1].repeat(p, 0), x[y == 0]), 0)
                Y = np.concatenate((y[y == 1].repeat(p, 0), y[y == 0]), 0)
        else:
            X = x
            Y = y
        loader = DataLoader(Subset(torch.tensor(X).float(), torch.Tensor(Y)
            ), batch_size=batch_size, shuffle=True, num_workers=workers)
        criterion = nn.BCEWithLogitsLoss()
        if opt_type == 'lbfgs':
            opt = torch.optim.LBFGS(self.parameters(), lr=lr)
        elif opt_type == 'adam':
            opt = torch.optim.Adam(self.parameters(), lr=lr)
            if nepochs == 2:
                nepochs = 200
        else:
            raise ValueError('opt_type must be lbfgs or adam')
        best_auc = self.auc(x, y)
        pat = 0
        if verb:
            None
        for epoch in range(nepochs):
            if verb:
                criterion(self(torch.Tensor(x)), torch.Tensor(y)).detach(
                    ).numpy().round(3)
                self.prior_loss().detach().numpy().round(3)
                self.auc(x, y).round(3)
                self.binary_acc(x, y).round(3)
                np.NAN if tst_x is None else self.auc(tst_x, tst_y).round(3)
                _alpha = self.get_alpha().detach().numpy()
                None
            if early_stopping:
                cur_auc = self.auc(x, y)
                if cur_auc < best_auc:
                    if pat < patience:
                        pat += 1
                    else:
                        if verb:
                            None
                        return
                else:
                    best_auc = cur_auc
                    pat = 0
            for batch in loader:
                _x, _y = batch['ims'], batch['labels']

                def loss_closure():
                    opt.zero_grad()
                    pred = self(_x)
                    loss = criterion(pred, _y) + self.prior_loss()
                    loss.backward()
                    return loss
                if opt_type == 'lbfgs':
                    opt.step(loss_closure)
                elif opt_type == 'adam':
                    loss_closure()
                    opt.step()
                else:
                    raise ValueError('opt_type must be lbfgs or adam')
        if (abs(self.alpha.detach().numpy()) > 1000000.0).any():
            raise RuntimeError('convergence failed')


def get_inputs():
    return [torch.rand([4, 4, 4, 4])]


def get_init_inputs():
    return [[], {}]

import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import numpy as np
from torch import nn
from torch.utils.data import DataLoader
from torchvision import transforms
from sklearn.preprocessing import StandardScaler
from sklearn import metrics
from torch.utils.data import Dataset
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda


@triton.jit
def triton_poi_fused_mul_sum_0(in_ptr0, in_ptr1, out_ptr0, xnumel, XBLOCK:
    tl.constexpr):
    xnumel = 64
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x2 = xindex // 16
    x3 = xindex % 16
    x0 = xindex % 4
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (x3 + 64 * x2), xmask)
    tmp1 = tl.load(in_ptr1 + x0, xmask, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr0 + (16 + x3 + 64 * x2), xmask)
    tmp6 = tl.load(in_ptr0 + (32 + x3 + 64 * x2), xmask)
    tmp9 = tl.load(in_ptr0 + (48 + x3 + 64 * x2), xmask)
    tmp2 = tmp0 * tmp1
    tmp4 = tmp3 * tmp1
    tmp5 = tmp2 + tmp4
    tmp7 = tmp6 * tmp1
    tmp8 = tmp5 + tmp7
    tmp10 = tmp9 * tmp1
    tmp11 = tmp8 + tmp10
    tl.store(out_ptr0 + x4, tmp11, xmask)


def call(args):
    primals_1, primals_2 = args
    args.clear()
    assert_size_stride(primals_1, (4, 4, 4, 4), (64, 16, 4, 1))
    assert_size_stride(primals_2, (4,), (1,))
    with torch.cuda._DeviceGuard(0):
        torch.cuda.set_device(0)
        buf0 = empty_strided_cuda((4, 4, 4), (16, 4, 1), torch.float32)
        get_raw_stream(0)
        triton_poi_fused_mul_sum_0[grid(64)](primals_1, primals_2, buf0, 64,
            XBLOCK=64, num_warps=1, num_stages=1)
        del primals_2
    return buf0, primals_1


def compute_auc(labels, scores, pos_label=1):
    fpr, tpr, _thresholds = metrics.roc_curve(labels, scores, pos_label=
        pos_label)
    return metrics.auc(fpr, tpr)


class Subset(Dataset):

    def __init__(self, data, labels, normalize=False):
        self.ims = data
        self.labels = labels
        self.normalize = normalize
        if normalize:
            self.T = transforms.Normalize(0.5, 0.5)
        else:
            self.T = lambda x: x

    def __getitem__(self, idx):
        ret = {'ims': self.T(self.ims[idx]), 'labels': self.labels[idx]}
        return ret

    def __len__(self):
        return self.labels.shape[0]


class RobustLogisticRegressionNew(nn.Module):

    def __init__(self, alpha=[1.0, 1.0, 1.0, 1.0], beta=1.0, alpha0=[1.0, 
        0.0, 0.0, 0.0]):
        super(RobustLogisticRegressionNew, self).__init__()
        self.alpha = nn.Parameter(torch.Tensor(alpha))
        if not len(alpha0) == 4:
            raise ValueError('alpha0 must be a vector og length 4')
        self.alpha0 = torch.Tensor(alpha0)
        self.beta = beta
        self.scaler = StandardScaler()

    def get_alpha(self):
        return self.alpha

    def predict_prob(self, x):
        return 1 / (1 + torch.exp(-self(x)))

    def predict(self, x):
        return torch.round(self.predict_prob(x))

    def prior_loss(self):
        return self.beta * torch.sqrt(torch.square(self.alpha0 - self.alpha
            ).sum())

    def binary_acc(self, x, y):
        y_true = np.array(y)
        y_pred = self.predict(x).detach().numpy()
        nhits = (y_pred == y_true).sum()
        return nhits / y_true.shape[0]

    def auc(self, x, y):
        scores = self.predict_prob(x)
        return compute_auc(y, scores.detach().numpy())

    def scaler_fit(self, x):
        self.scaler.fit(x)

    def scaler_transform(self, x):
        return self.scaler.transform(x)

    def save_weights(self, f):
        np.save(f, self.alpha_params.detach().numpy())

    def fit(self, x, y, tst_x=None, tst_y=None, nepochs=2, batch_size=256,
        lr=0.01, opt_type='lbfgs', workers=1, balanced=True, verb=True,
        scale=False, early_stopping=False, patience=10):
        if scale:
            self.scaler_fit(x)
            x = self.scaler_transform(x)
            tst_x = tst_x if tst_x is None else self.scaler_transform(tst_x)
        if balanced:
            n1 = int(sum(y))
            n0 = len(y) - n1
            if n0 < n1:
                p = int(np.floor(n1 / n0))
                X = np.concatenate((x[y == 0].repeat(p, 0), x[y == 1]), 0)
                Y = np.concatenate((y[y == 0].repeat(p, 0), y[y == 1]), 0)
            else:
                p = int(np.floor(n0 / n1))
                X = np.concatenate((x[y == 1].repeat(p, 0), x[y == 0]), 0)
                Y = np.concatenate((y[y == 1].repeat(p, 0), y[y == 0]), 0)
        else:
            X = x
            Y = y
        loader = DataLoader(Subset(torch.tensor(X).float(), torch.Tensor(Y)
            ), batch_size=batch_size, shuffle=True, num_workers=workers)
        criterion = nn.BCEWithLogitsLoss()
        if opt_type == 'lbfgs':
            opt = torch.optim.LBFGS(self.parameters(), lr=lr)
        elif opt_type == 'adam':
            opt = torch.optim.Adam(self.parameters(), lr=lr)
            if nepochs == 2:
                nepochs = 200
        else:
            raise ValueError('opt_type must be lbfgs or adam')
        best_auc = self.auc(x, y)
        pat = 0
        if verb:
            None
        for epoch in range(nepochs):
            if verb:
                criterion(self(torch.Tensor(x)), torch.Tensor(y)).detach(
                    ).numpy().round(3)
                self.prior_loss().detach().numpy().round(3)
                self.auc(x, y).round(3)
                self.binary_acc(x, y).round(3)
                np.NAN if tst_x is None else self.auc(tst_x, tst_y).round(3)
                _alpha = self.get_alpha().detach().numpy()
                None
            if early_stopping:
                cur_auc = self.auc(x, y)
                if cur_auc < best_auc:
                    if pat < patience:
                        pat += 1
                    else:
                        if verb:
                            None
                        return
                else:
                    best_auc = cur_auc
                    pat = 0
            for batch in loader:
                _x, _y = batch['ims'], batch['labels']

                def loss_closure():
                    opt.zero_grad()
                    pred = self(_x)
                    loss = criterion(pred, _y) + self.prior_loss()
                    loss.backward()
                    return loss
                if opt_type == 'lbfgs':
                    opt.step(loss_closure)
                elif opt_type == 'adam':
                    loss_closure()
                    opt.step()
                else:
                    raise ValueError('opt_type must be lbfgs or adam')
        if (abs(self.alpha.detach().numpy()) > 1000000.0).any():
            raise RuntimeError('convergence failed')

    def forward(self, input_0):
        primals_2 = self.alpha
        primals_1 = input_0
        output = call([primals_1, primals_2])
        return output[0]
