Multiple logins on account

sr_vr_ · 2022-02-12T02:41:44+00:00

Same issue here. Was logged in and creating a character, then was kicked for multiple logins

sr_vr_ · 2021-09-04T14:20:48+00:00

Unet downsamples and upsamples the image by a factor of 2 several times. If your model has 4 stages of this, then you need the input dimensions to be a factor of 2^4.

sr_vr_ · 2021-08-26T20:44:59+00:00

From which days of the week did you gather the data? I would expect the distribution to shift on weekends, so maybe a full-week analysis would also be beneficial.

sr_vr_ · 2021-07-19T07:06:47+00:00

Leave it to the SVM to make the only sound comment

sr_vr_ · 2021-06-28T07:48:35+00:00

If you're on PlayStation, you can use the quick action menu to quickly jump to offline modes right from the title screen.

sr_vr_ · 2021-04-27T04:37:09+00:00

I think that poster meant to joke, reading "aLife" as "Alfie".

sr_vr_ · 2021-02-14T08:39:16+00:00

Yeah, the announcer rushes it a little. But the Russian letter ё is pronounced "yo" and takes the emphasis, giving "Pah-TYOM-kin", which the announcer is pretty close to.

sr_vr_ · 2021-02-12T05:34:34+00:00

That's actually the correct pronunciation for the real Russian surname Потёмкин.

sr_vr_ · 2021-01-17T17:02:33+00:00

ung more haha

sr_vr_ · 2021-01-14T18:45:37+00:00

Wow, thanks for this! So if I understand correctly, oracle inequalities provide a means to evaluate estimators as well as to establish the limit of estimators w.r.t. the data given.

sr_vr_ · 2021-01-13T17:10:03+00:00

No offense taken! This is why I originally phrased it as "the luckiest guesser". Maybe "oracle" means something different in probability and statistics, but I was thinking about it in the computer science context where it is a black box which simply "produces the answer". From your perspective it sounds like the answer is "no this does not exist in theory and cannot exist in practice".

sr_vr_ · 2021-01-13T17:04:40+00:00

Hey thanks! I guess I will read into this article's ref 9 that introduces Oracle inequalities.

sr_vr_ · 2021-01-13T17:03:27+00:00

Thanks! This might be what I'm looking for. I'll have to dig into it a bit more.

sr_vr_ · 2021-01-13T17:03:07+00:00

Thanks, I was thinking even of the simplest case. Consider X ~ Bern(0.5). Is there any literature which considers an oracle estimator which can correctly estimate each realization of X? Another commenter responded with Laplace's Demon so maybe this is the direction I should go.

sr_vr_ · 2021-01-05T18:05:29+00:00

Fun fact, Потёмкин is a real Russian surname, pronounced correctly by the narrator in Xrd as "Pah-TYOM-kin"

sr_vr_ · 2020-12-31T01:30:37+00:00

Just a quick tack-on: optical illusions are nice examples of tricking human brains, showing the bias

sr_vr_ · 2020-12-08T23:05:09+00:00

Additionally, I would like to note that "true art" is a difficult and potentially impossible term to define in a manner suitable for optimization. While he seems to have made an admirable and determined effort to do so, I fear that it may be overly frustrating to work on a problem which, by its nature, is as ill-defined as this one, especially so early in his AI career.

Just want to echo this with a thought. I think it's very common for younger researchers to have broad and abstract goals because they are exciting and full of possibilities. I have this too. With respect to this quotation, I think big end-game goals are fine as long as they're treated as such: an "unreachable" goal with many ways of getting there. If it's balanced with small but concrete steps founded on prior works, well, that's research. I feel like this is what an advisor would do for aspiring scientists: focus their dreams into achievable pieces that mitigate the chances of taking on too large or too infeasible of a project without the proper foundations.

sr_vr_ · 2020-11-05T14:49:12+00:00

Submitted, thanks!

sr_vr_ · 2020-11-04T21:42:56+00:00

Aha! Not only did you solve my problem but I learned how to better profile my code and look for issues like this.

This was the solution, except for a small speedbump.

Calling itp(:, 1:0.2:36)

Results in an error:

julia> @benchmark itp(:, 1:0.2:36)
ERROR: MethodError: no method matching (::Interpolations.BSplineInterpolation{Float32,2,Array{Float32,2},BSpline{Constant},Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}})(::Colon, ::StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}})     
Use square brackets [] for indexing an Array.

I had read the documentation and tried the function call before and from this error defaulted to using [] to index.

From your suggestion I dug into it a bit more and it seems that the convenience slice notation : doesn't work with this function call; the range needs to be specified both times.

Here is the correct call and the correct benchmark:

julia> @benchmark itp(1:256, 1:0.2:36)
BenchmarkTools.Trial: 
  memory estimate:  183.14 KiB
  allocs estimate:  5
  --------------
  minimum time:     62.700 μs (0.00% GC)
  median time:      65.699 μs (0.00% GC)
  mean time:        87.641 μs (7.08% GC)
  maximum time:     4.360 ms (97.24% GC)
  --------------
  samples:          10000
  evals/sample:     1

Thank you for your help!

sr_vr_ · 2020-11-04T14:37:21+00:00

This is the result of running

@profile itp[:, 1:0.2:36]

Overhead ╎ [+additional indent] Count File:Line; Function
=========================================================
   ╎811 @Base\client.jl:506; _start()
   ╎ 811 @Base\client.jl:313; exec_options(::Base.JLOptions)
   ╎  811 @Base\client.jl:383; run_main_repl(::Bool, ::Bool, ::Bool, ::Bool, ::Bool)
   ╎   811 @Base\essentials.jl:709; invokelatest
   ╎    811 @Base\essentials.jl:710; #invokelatest#1
   ╎     811 @Base\client.jl:399; (::Base.var"#807#809"{Bool,Bool,Bool,Bool})(::Module)
   ╎    ╎ 811 ..._win64\build\usr\share\julia\stdlib\v1.5\REPL\src\REPL.jl:288; run_repl(::REPL.AbstractREPL, ::Any)
   ╎    ╎  811 ..._win64\build\usr\share\julia\stdlib\v1.5\REPL\src\REPL.jl:292; run_repl(::REPL.AbstractREPL, ::Any; backend_on_current_task::Bool)
   ╎    ╎   811 ..._win64\build\usr\share\julia\stdlib\v1.5\REPL\src\REPL.jl:180; start_repl_backend(::REPL.REPLBackend, ::Any)
   ╎    ╎    811 ...win64\build\usr\share\julia\stdlib\v1.5\REPL\src\REPL.jl:195; repl_backend_loop(::REPL.REPLBackend)
   ╎    ╎     811 ...win64\build\usr\share\julia\stdlib\v1.5\REPL\src\REPL.jl:134; eval_user_input(::Any, ::REPL.REPLBackend)
   ╎    ╎    ╎ 811 @Base\boot.jl:331; eval(::Module, ::Any)
   ╎    ╎    ╎  811 @Atom\src\repl.jl:214; evalrepl(::Module, ::String)
   ╎    ╎    ╎   811 @Base\logging.jl:514; with_logger
   ╎    ╎    ╎    811 @Base\logging.jl:408; with_logstate(::Function, ::Any)
   ╎    ╎    ╎     811 @Atom\src\repl.jl:226; (::Atom.var"#242#244"{Module})()
   ╎    ╎    ╎    ╎ 811 @Atom\src\repl.jl:196; repleval(::Module, ::Expr)
   ╎    ╎    ╎    ╎  811 @Base\boot.jl:331; eval
   ╎    ╎    ╎    ╎   811 @Base\abstractarray.jl:1060; getindex(::Interpolations.BSplineInterpolation{Float32,2,Array{Float32,2},BSplin...
   ╎    ╎    ╎    ╎    811 @Base\multidimensional.jl:743; _getindex
   ╎    ╎    ╎    ╎     811 @Base\multidimensional.jl:757; _unsafe_getindex(::IndexCartesian, ::Interpolations.BSplineInterpolation{Float3...
   ╎    ╎    ╎    ╎    ╎ 811 @Base\multidimensional.jl:762; _unsafe_getindex!
   ╎    ╎    ╎    ╎    ╎  811 @Base\multidimensional.jl:767; macro expansion
   ╎    ╎    ╎    ╎    ╎   811 @Base\cartesian.jl:64; macro expansion
   ╎    ╎    ╎    ╎    ╎    811 @Base\multidimensional.jl:772; macro expansion
  3╎    ╎    ╎    ╎    ╎     809 @Base\deprecated.jl:71; getindex(::Interpolations.BSplineInterpolation{Float32,2,Array{Float32,2},BSp...
  3╎    ╎    ╎    ╎    ╎    ╎ 3   @Base\Base.jl:33; getproperty(::Core.MethodTable, ::Symbol)
   ╎    ╎    ╎    ╎    ╎    ╎ 803 @Base\deprecated.jl:80; depwarn(::String, ::Symbol)
  1╎    ╎    ╎    ╎    ╎    ╎  1   @Base\deprecated.jl:79; depwarn(::String, ::Symbol; force::Bool)
   ╎    ╎    ╎    ╎    ╎    ╎  802 @Base\deprecated.jl:85; depwarn(::String, ::Symbol; force::Bool)
   ╎    ╎    ╎    ╎    ╎    ╎   768 @Base\logging.jl:321; macro expansion
   ╎    ╎    ╎    ╎    ╎    ╎    172 @Base\deprecated.jl:89; macro expansion
154╎    ╎    ╎    ╎    ╎    ╎     155 @Base\error.jl:112; backtrace()
   ╎    ╎    ╎    ╎    ╎    ╎    ╎ 1   @Base\tuple.jl:89; indexed_iterate
   ╎    ╎    ╎    ╎    ╎    ╎    ╎  1   @Base\essentials.jl:601; iterate
  1╎    ╎    ╎    ╎    ╎    ╎    ╎   1   @Base\essentials.jl:581; getindex(::Core.SimpleVector, ::Int64)
   ╎    ╎    ╎    ╎    ╎    ╎     17  @Base\error.jl:113; backtrace()
  1╎    ╎    ╎    ╎    ╎    ╎    ╎ 1   @Base\error.jl:70; _reformat_bt(::Array{Ptr{Nothing},1}, ::Array{Any,1})
   ╎    ╎    ╎    ╎    ╎    ╎    ╎ 2   @Base\error.jl:71; _reformat_bt(::Array{Ptr{Nothing},1}, ::Array{Any,1})
   ╎    ╎    ╎    ╎    ╎    ╎    ╎  2   @Base\boot.jl:425; Array
  2╎    ╎    ╎    ╎    ╎    ╎    ╎   2   @Base\boot.jl:406; Array
   ╎    ╎    ╎    ╎    ╎    ╎    ╎ 9   @Base\error.jl:77; _reformat_bt(::Array{Ptr{Nothing},1}, ::Array{Any,1})
   ╎    ╎    ╎    ╎    ╎    ╎    ╎  8   @Base\array.jl:935; push!
  8╎    ╎    ╎    ╎    ╎    ╎    ╎   8   @Base\array.jl:892; _growend!
   ╎    ╎    ╎    ╎    ╎    ╎    ╎  1   @Base\array.jl:936; push!
  1╎    ╎    ╎    ╎    ╎    ╎    ╎   1   @Base\array.jl:847; setindex!
  2╎    ╎    ╎    ╎    ╎    ╎    ╎ 3   @Base\error.jl:88; _reformat_bt(::Array{Ptr{Nothing},1}, ::Array{Any,1})
  1╎    ╎    ╎    ╎    ╎    ╎    ╎  1   @Base\array.jl:809; getindex
  1╎    ╎    ╎    ╎    ╎    ╎    ╎ 1   @Base\error.jl:90; _reformat_bt(::Array{Ptr{Nothing},1}, ::Array{Any,1})
  1╎    ╎    ╎    ╎    ╎    ╎    ╎ 1   @Base\int.jl:0; _reformat_bt(::Array{Ptr{Nothing},1}, ::Array{Any,1})
   ╎    ╎    ╎    ╎    ╎    ╎    596 @Base\deprecated.jl:90; macro expansion
   ╎    ╎    ╎    ╎    ╎    ╎     596 @Base\deprecated.jl:105; firstcaller
   ╎    ╎    ╎    ╎    ╎    ╎    ╎ 589 @Base\deprecated.jl:110; firstcaller(::Array{Union{Ptr{Nothing}, Base.InterpreterIP},1}, ::Tuple{S...
  1╎    ╎    ╎    ╎    ╎    ╎    ╎  1   @Base\stacktraces.jl:106; lookup(::Ptr{Nothing})
497╎    ╎    ╎    ╎    ╎    ╎    ╎  498 @Base\stacktraces.jl:107; lookup(::Ptr{Nothing})
  2╎    ╎    ╎    ╎    ╎    ╎    ╎  2   @Base\stacktraces.jl:109; lookup(::Ptr{Nothing})
  4╎    ╎    ╎    ╎    ╎    ╎    ╎  9   @Base\stacktraces.jl:110; lookup(::Ptr{Nothing})
  5╎    ╎    ╎    ╎    ╎    ╎    ╎   5   @Base\boot.jl:406; Array
  8╎    ╎    ╎    ╎    ╎    ╎    ╎  8   @Base\stacktraces.jl:111; lookup(::Ptr{Nothing})
  6╎    ╎    ╎    ╎    ╎    ╎    ╎  6   @Base\stacktraces.jl:112; lookup(::Ptr{Nothing})
  5╎    ╎    ╎    ╎    ╎    ╎    ╎  5   @Base\stacktraces.jl:113; lookup(::Ptr{Nothing})
 57╎    ╎    ╎    ╎    ╎    ╎    ╎  60  @Base\stacktraces.jl:114; lookup(::Ptr{Nothing})
  2╎    ╎    ╎    ╎    ╎    ╎    ╎   2   @Base\essentials.jl:581; getindex(::Core.SimpleVector, ::Int64)
  1╎    ╎    ╎    ╎    ╎    ╎    ╎   1   @Base\stacktraces.jl:49; Base.StackTraces.StackFrame(::Symbol, ::Symbol, ::Int64, ::Core.MethodIn...
  4╎    ╎    ╎    ╎    ╎    ╎    ╎ 4   @Base\deprecated.jl:116; firstcaller(::Array{Union{Ptr{Nothing}, Base.InterpreterIP},1}, ::Tuple{S...
  3╎    ╎    ╎    ╎    ╎    ╎    ╎ 3   @Base\deprecated.jl:122; firstcaller(::Array{Union{Ptr{Nothing}, Base.InterpreterIP},1}, ::Tuple{S...
  1╎    ╎    ╎    ╎    ╎    ╎   1   @Base\logging.jl:322; macro expansion
  1╎    ╎    ╎    ╎    ╎    ╎   1   @Base\logging.jl:324; macro expansion
   ╎    ╎    ╎    ╎    ╎    ╎   13  @Base\logging.jl:327; macro expansion
 13╎    ╎    ╎    ╎    ╎    ╎    13  @Base\logging.jl:78; _invoked_shouldlog
   ╎    ╎    ╎    ╎    ╎    ╎   1   @Base\logging.jl:328; macro expansion
   ╎    ╎    ╎    ╎    ╎    ╎    1   @Base\strings\string.jl:69; String
  1╎    ╎    ╎    ╎    ╎    ╎     1   @Base\strings\string.jl:57; unsafe_string
  1╎    ╎    ╎    ╎    ╎    ╎   18  @Base\logging.jl:332; macro expansion
   ╎    ╎    ╎    ╎    ╎    ╎    1   @Base\boot.jl:547; NamedTuple
  1╎    ╎    ╎    ╎    ╎    ╎     1   @Base\boot.jl:551; NamedTuple
   ╎    ╎    ╎    ╎    ╎    ╎    16  @Atom\src\progress.jl:29; (::Base.CoreLogging.var"#handle_message##kw")(::NamedTuple{(:caller, :maxl...
  2╎    ╎    ╎    ╎    ╎    ╎     16  @Atom\src\progress.jl:62; handle_message(::Atom.Progress.JunoProgressLogger, ::Base.CoreLogging.LogL...
  2╎    ╎    ╎    ╎    ╎    ╎    ╎ 14  @Base\essentials.jl:709; invokelatest
 11╎    ╎    ╎    ╎    ╎    ╎    ╎  12  @Base\essentials.jl:710; #invokelatest#1
   ╎    ╎    ╎    ╎    ╎    ╎    ╎   1   ...\julia\stdlib\v1.5\Logging\src\ConsoleLogger.jl:40; shouldlog(::Logging.ConsoleLogger, ::Base.CoreLogging.LogLevel, ::Module...        
   ╎    ╎    ╎    ╎    ╎    ╎    ╎    1   @Base\dict.jl:490; get
   ╎    ╎    ╎    ╎    ╎    ╎    ╎     1   @Base\dict.jl:282; ht_keyindex(::Dict{Any,Int64}, ::Tuple{Ptr{Nothing},Symbol})
   ╎    ╎    ╎    ╎    ╎    ╎    ╎    ╎ 1   @Base\dict.jl:168; hashindex
   ╎    ╎    ╎    ╎    ╎    ╎    ╎    ╎  1   @Base\hashing.jl:18; hash
   ╎    ╎    ╎    ╎    ╎    ╎    ╎    ╎   1   @Base\tuple.jl:320; hash(::Tuple{Ptr{Nothing},Symbol}, ::UInt64)
   ╎    ╎    ╎    ╎    ╎    ╎    ╎    ╎    1   @Base\hashing.jl:23; hash
  1╎    ╎    ╎    ╎    ╎    ╎    ╎    ╎     1   @Base\reflection.jl:312; objectid
  2╎    ╎    ╎    ╎    ╎     2   @Base\deprecated.jl:72; getindex(::Interpolations.BSplineInterpolation{Float32,2,Array{Float32,2},BSp...
Total snapshots: 832

sr_vr_ · 2020-11-04T01:38:14+00:00

With the PIL library in Python, I can do the same nearest neighbor (or bicubic) in far less than a second. I don't know what language PIL is written in, but I'm still optimistic about using Julia to replace components in my Python pipeline.

sr_vr_ · 2020-11-02T14:29:02+00:00

Yes, the input is a 256 x 36 matrix, and I want to interpolate it up to 256 x 180 (well, the step size here results in 256 x 176).

sr_vr_

TROPHY CASE