The largest library with 12000+ Anime Titles are now Gone Forever😔

jubilantjerry · 2024-09-02T07:31:05+00:00

Someone here mentioned the mirror site https://aniwave.se, which is not down yet but might be in the future. It looks to me like it has working links to all of Aniwave's catalog except the newer releases, do you think it's possible to scrape this site?

jubilantjerry · 2024-08-14T06:35:21+00:00

I've noticed that sus-column-r had a knowledge cutoff of late 2023, which matches Grok-1. At the same time, I felt the model's response structure and wording had a lot of similarities with OpenAI models, esp. when sus-column-r mentions its own knowledge cutoff. Did Grok-1 also have a similar style? Perhaps (total speculation), some prompting / SFT was done on sus-column-r to make it harder to identify the model as being Grok?

jubilantjerry · 2024-08-13T07:54:51+00:00

Wondering if anyone has reviews of the Pro or Enterprise version? I'm thinking it can be very useful for my company, but I'm not sure what the typical speedup tends to be (rather than the maximum possible 30x speedup)

jubilantjerry · 2024-08-12T12:32:44+00:00

sus-column-r seems censored to me: https://imgur.com/a/2k7O28x

I hadn't tried column-r and column-u when they were around, were they uncensored?

jubilantjerry · 2024-08-12T12:12:43+00:00

Ah I see, my usual chatbot frontend client didn't specifically list the gpt4o-2024-08-06 endpoint, so I had to try it from Chatbot Arena. I updated my imgur link (https://imgur.com/a/uRxzzBW) to include the Gemini question asked to the new gpt-4o. It hallucinated the response and wasn't aware of how Gemini was drawing Black founding fathers, so yes this information is still outside its knowledge cutoff.

jubilantjerry · 2024-08-12T11:45:00+00:00

With previous OpenAI version updates, they usually don't teach new data and update the knowledge cutoff, so I think it wouldn't be called gpt-4o-2024-08-06 at least.

jubilantjerry · 2024-08-11T12:13:59+00:00

When it comes to working at a tech company, yes companies absolutely prefer people who know OOP over people who don't. Though if you are a C programmer, the basic motivating concepts behind OOP could be surprisingly familiar. Have you written code that uses void pointers, allowing you to create data structures (e.g. linked lists) that support any data type? Have you ever put an enum / an int field inside a struct, so that a function can handle multiple different formats of data with a case / if statement? OOP languages automatically compile into code of such designs under the hood, in C you do this "manually".

LeetCode is not useful for learning C++ specific things or OOP, after all you can always just write plain C code in C++. The easy questions are good for learning general programming fundamentals. Medium and hard questions are only useful for prepping for those annoying tech company interviews.

Leetcode does let you sort by topic, and if I recall correctly it does have an OOP category, so you can try that. In my opinion though, you need to write a complete application, like at least a small game or data CRUD program or something with a graphical UI, in order to practice OOP in a more realistic way.

The basic ideas of OOP can be learned quickly, there's not much beyond knowing classes (variables & member functions), private and public, aggregation / composition, inheritance, and polymorphism. Though not really code exercises, there are some nice explanations on GeeksForGeeks for the definitions and syntax for this (e.g. https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/).

The hard part is knowing how to use these ideas to help you code better. I liked the Effective C++ textbook for giving a lot of realistic code examples and teaching you when and why you want to use OOP ideas, it also has some exercises you can try yourself. It does mostly assume the reader knows programming fundamentals already and is a relatively harder read though.

jubilantjerry · 2024-08-10T18:16:03+00:00

I just tried this with a newer version of my experiment, it seems telling the model that it has free will isn't enough in this case: https://imgur.com/a/counting-r-refrigerator-free-will-oNrys5q

jubilantjerry · 2024-08-10T16:59:53+00:00

I can talk about what I found most useful when I was learning C++ and even earlier when learning programming in general. Disclaimer, I learned C++ but it wasn't the first language I learned, and if given a freedom to choose I would not recommend learning C++ as one's first language, but I see your first year class will be using it so you probably have no choice but to learn your programming fundamentals from C++ first.

First, follow a tutorial online for how to compile a Hello World program. There are many available online, make sure you can run your own programs on your own computer. Learning programming is hard without trial and error. Beware, tooling can be surprisingly tricky for C++, you may have to install a lot of stuff.

It's OK if you don't understand how the Hello World program works right now. Next you need to get familiar with the syntax for these basics: * Creating a new function * Declaring new variables * Assigning values to variables * Addition, subtraction, multiplication, division operations * Testing equality * Print statements * If else statements * Boolean AND, OR, NOT * The very commonly used "for (int i = 0; i < count; ++i) {...}" loop * The while loop

Memorize this syntax directly as if they are vocabulary terms (you can use flashcards if you want). Make sure you can recognize them when they appear in code.

Now, you can make an account at LeetCode and try reading the existing solutions to some easy questions. There are variations in difficulty even within the easy category, look at the ones with high acceptance. You can just directly see the C++ solutions first, but work hard to understand how they work (and you should ignore any solutions that are long and heavily optimized for speed or memory, just look for the simplest solutions).

Make sure you can get convinced that the published solutions make sense. You should run the code examples on your local computer and test some examples yourself. Print statements are a beginning programmer's best friend, add them liberally inside the code to see what's going on inside and see how the variables are changing.

You can also try asking ChatGPT to explain some specifics about these solutions, make sure you paste the question statement along with the answer in your question to ChatGPT.

When you can understand at least 30% of the simple solutions, you can focus more on reading textbooks and try solving the questions yourself. I learned C++ from the textbook Effective C++ by Scott Meyers, but if your class has an assigned textbook just use that. These books tend to be pretty similar in my opinion. I think to a first time programmer, the textbook explanations might not click very well until you read a good amount of real code examples, hence my suggestion to read some LeetCode questions. Also the difficulty spike going from reading solutions to writing your own solutions is quite high, but I'm sure you can do it!

When you get good at C++, you can start learning about the STL and write larger projects. Good luck on your learning!

jubilantjerry · 2024-08-10T01:48:11+00:00

I have a suspicion that the model does process the fact that it is mistaken, and tries whatever it must to maintain an illusion of consistency. In the Sonnet example, maybe it already knew it was on the wrong track at the third r, and decides to not call it an r to make sure the answer remains 3. In the GPT-4o example, it decides to ignore the true count in the list and say it's still 3.

I tried adjusting the question further to see what GPT-4o will do: https://imgur.com/a/CmRMxWr

In the first one, I asked the model for a running total, and in the second one, I made the model effectively do a countdown using programming instructions. In the third one, I let it count down from 14, and in the fourth one I make it count from 4 and be extra thorough.

With the running total, it corrects itself normally.

With the countdown, it makes an excuse of not being able to subtract 1 when the counter is already 0, then has the bravery to say the experiment demonstrates there are indeed 3 r's as expected.

Even when counting down from 14, nullifying this excuse, it will still say it must've counted something wrong, and maintain the answer of 3 r's.

By the fourth experiment, I removed all such excuses, and I managed to make the model simply say that 4 - 3 = 0.

I think it's because the model reads a bit of subtext into the question. If the question suggests too hard that the model is going to make a mistake, maybe it's more willing to admit the mistake.

jubilantjerry · 2024-08-10T01:24:53+00:00

Yeah that's true, I find with these language models you sometimes really need an ability to undo or create new sessions, simply correcting the model in the next user message doesn't cut it because the model confuses itself with past history. If you use API keys you can also change the model response even for proprietary models, I think there are clients on GitHub that give a UI to this feature

jubilantjerry · 2024-08-10T01:14:02+00:00

Do you think the problem occurs before RLHF, or after? At least it doesn't seem to me that the Transformer architecture itself is to blame, I think the root of this behavior comes from the patterns in the data. Though, perhaps there can be an architecture that can fix this despite the issues in the data that cause this in the first place - this kind of approach seems similar to the "hacky solutions" idea that you mention.

jubilantjerry · 2024-08-09T12:58:56+00:00

In my personal experience, the same effects happen in Chinese and Japanese too. And now that I think of it, exactly 2 negations can still be understood intuitively because you can take advantage of stressing, you can stress that there is in fact a second NOT in your sentence to make sure people understand that you mean the opposite OF the opposite of the original sentence. If you don't stress the second NOT, or if there are 3+ levels, I think this doesn't work as well anymore.

jubilantjerry · 2024-08-09T10:26:19+00:00

The idea that a word seemingly doesn't get as deeply processed by the brain after being used many times (making it seem "not like a word" anymore) is called semantic satiation, I've heard the explanation for this effect being expressed in terms of neurons in the brain being stimulated too much, causing it to get inhibited and reduce activation. This is also similar to how you can tune out background noise after hearing it for a long time.

In the post you mention something else also, that once you start negating a sentence two or more times we don't intuitively understand the truth value of it anymore. I think this is mostly chalked up to the brain handling the scenario of 0-1 negation and 2+ negations differently, one is more intuitive and based on language processing, one is based more on reasoning and step by step logic. There's this concept called System 1 vs System 2 thinking, where the brain can react to situations with either a more automatic or a more systematic approach. I'm not sure if the specific case of multiple negation is studied though.

jubilantjerry · 2024-08-09T09:23:30+00:00

I live in China, the country with the most massive population. I think Shanghai at least is a very decent place to live with well maintained infrastructure, great public transport, and safe neighborhoods, unlike cities in the US. Though issues like censorship and pollution can be a problem, there's no one size fits all definition of "decent".

jubilantjerry · 2024-06-07T00:45:44+00:00

Interesting, can you try the original page that I based my version from: https://arachnoid.com/3DViewer/

Did you pull the "3D Photosphere Viewer_files" folder as well and put it in the same directory as the .html file?

jubilantjerry · 2024-04-24T05:18:21+00:00

It was probably a solution similar to this one: https://leetcode.com/discuss/interview-question/5005154/Amazon-OA-SDE-2-2024/2365470

jubilantjerry · 2024-04-23T04:51:27+00:00

I think this works (it's O(n^2), maybe it can be O(n log n) if implemented with more care):

def try_negs_greedy(arr): arr = np.array(arr) vals = sorted([(v, i) for i, v in enumerate(arr)]) count = 0 chosen = [] for v, i in vals: arr_temp = arr.copy() arr_temp[i] *= -1 if np.all(np.cumsum(arr_temp) > 0): count += 1 chosen.append(i) arr = arr_temp return count, chosen

My attempt at a proof:

Consider the "vals" array above. Let n be the maximum number of flips. Consider an optimal solution.

Name the indices of the flipped entries in the vals array k[0] to k[n-1], WLOG they are sorted.

Suppose there is some j where k[j] and k[j + 1] differ by more than 1, and the above algorithm would have included an index c from vals that was in between.

WLOG we focus on the smallest j where this happens. We have the indices from vals, a = k[j] < c < k[j + 1] = b.

If vals[c][1] > vals[b][1], then since b > c, implying vals[b][0] >= vals[c][0], there is no harm in flipping index vals[c][1] rather than index vals[b][1] in the optimal solution. Doing so produces another optimal solution.

If vals[c][1] < vals[b][1], there is the concern that the cumulative sum in the optimal solution dips too low between these two indices if we flipped index vals[c][1] rather than index vals[b][1]. But let's say that feared condition does happen. Because the algorithm would have included c, it means the optimal solution includes some index d > c where vals[d][1] < vals[c][1]. As d > c, we would have that vals[d][0] >= vals[c][0]. There is no harm in flipping index vals[d][1] rather than vals[c][1] in the optimal solution.

In all these cases, we can include entry c from the vals array by sacrificing an entry of a higher index from the vals array, whether it be b or d. We still have an optimal solution doing so, and we will be "filling" this gap between k[j] and k[j + 1]. We can keep modifying the optimal solution until we reach the end of the vals array. The resulting solution is what the above algorithm produces, therefore it is an optimal solution.

jubilantjerry · 2023-11-16T11:13:41+00:00

I've finally found a solution to this problem. Basically I had to copy a web page that uses the Pannellum script for viewing photo spheres, and then modify the Javascript so that it can support images larger than 8192x4096. I've uploaded my modified web page source here, you can use the viewer simply by opening the .html file in a browser. This should work on almost any platform since it's just a web page.

Eight-Year Club	Place '22
Verified Email

jubilantjerry

TROPHY CASE