Jak zapobiec rozłączaniu się Google Colab?

P: Czy istnieje sposób, aby programowo uniemożliwić Google Colab rozłączanie się po przekroczeniu limitu czasu?

Poniżej opisano warunki powodujące automatyczne odłączanie notebooka:

Notatniki Google Colab mają 90 minut bezczynności i bezwzględny limit 12 godzin. Oznacza to, że jeśli użytkownik nie wejdzie w interakcję ze swoim notatnikiem Google Colab przez ponad 90 minut, jego wystąpienie zostanie automatycznie zakończone. Ponadto maksymalny czas życia instancji Colab to 12 godzin.

Oczywiście chcemy automatycznie wycisnąć maksimum z instancji, bez konieczności ciągłej ręcznej interakcji z nią . Tutaj przyjmę powszechnie spotykane wymagania systemowe:

• Systemy operacyjne Ubuntu 18 LTS / Windows 10 / Mac
• W przypadku systemów opartych na Linuksie przy użyciu popularnych DE, takich jak Gnome 3 czy Unity
• Przeglądarki Firefox lub Chromium

Powinienem tutaj zaznaczyć, że takie zachowanie nie narusza Warunków użytkowania Google Colab , chociaż nie jest zalecane zgodnie z ich FAQ (w skrócie: moralnie nie jest w porządku, aby zużywać wszystkie GPU, jeśli tak naprawdę tego nie potrzebujesz ).

Moje obecne rozwiązanie jest bardzo głupie:

• Najpierw wyłączam wygaszacz ekranu, więc mój ekran jest zawsze włączony.
• Mam płytę Arduino, więc po prostu zamieniłem ją w gumową kaczuszkę USB i sprawiłem, że emuluje prymitywną interakcję użytkownika podczas snu (tylko dlatego, że mam ją pod ręką do innych zastosowań).

Czy są lepsze sposoby?

Edycja: Najwyraźniej rozwiązanie jest bardzo łatwe i nie wymaga żadnego JavaScript. Po prostu utwórz nową komórkę na dole, mającą następujący wiersz:

while True:pass

teraz utrzymuj komórkę w sekwencji uruchamiania, aby nieskończona pętla się nie zatrzymywała, a tym samym utrzyma twoją sesję przy życiu.

Stara metoda: ustaw interwał javascript, aby klikać przycisk połączenia co 60 sekund. Otwórz ustawienia programisty (w przeglądarce internetowej) za pomocą Ctrl + Shift + I, a następnie kliknij kartę konsoli i wpisz to w wierszu polecenia konsoli. (na Macu naciśnij Option + Command + I)

function ConnectButton(){
    console.log("Connect pushed"); 
    document.querySelector("#top-toolbar > colab-connect-button").shadowRoot.querySelector("#connect").click() 
}
setInterval(ConnectButton,60000);

Ponieważ identyfikator przycisku połączenia jest teraz zmieniony na „colab-connect-button”, poniższy kod może być używany do ciągłego klikania przycisku.

function ClickConnect(){
    console.log("Clicked on connect button"); 
    document.querySelector("colab-connect-button").click()
}
setInterval(ClickConnect,60000)

Jeśli nadal, to nie działa, wykonaj kroki podane poniżej:

1. Kliknij prawym przyciskiem myszy przycisk łączenia (w prawym górnym rogu kolumny)
2. Kliknij Sprawdź
3. Pobierz identyfikator HTML przycisku i zamień go w poniższym kodzie

function ClickConnect(){
    console.log("Clicked on connect button"); 
    document.querySelector("Put ID here").click() // Change id here
}
setInterval(ClickConnect,60000)

Cóż, to działa dla mnie -

uruchom następujący kod w konsoli, co uniemożliwi rozłączenie. Ctrl + Shift + I, aby otworzyć widok inspektora. Następnie przejdź do konsoli.

function ClickConnect(){
    console.log("Working"); 
    document.querySelector("colab-toolbar-button#connect").click() 
}
setInterval(ClickConnect,60000)

Jak zapobiec rozłączaniu się Google Colab

Dla mnie następujące przykłady:

• document.querySelector("#connect").click() lub
• document.querySelector("colab-toolbar-button#connect").click() lub
• document.querySelector("colab-connect-button").click()

rzucały błędy.

Musiałem dostosować je do następujących:

Wersja 1:

function ClickConnect(){
  console.log("Connnect Clicked - Start"); 
  document.querySelector("#top-toolbar > colab-connect-button").shadowRoot.querySelector("#connect").click();
  console.log("Connnect Clicked - End"); 
};
setInterval(ClickConnect, 60000)

Wersja 2: Jeśli chcesz mieć możliwość zatrzymania funkcji, oto nowy kod:

var startClickConnect = function startClickConnect(){
    var clickConnect = function clickConnect(){
        console.log("Connnect Clicked - Start");
        document.querySelector("#top-toolbar > colab-connect-button").shadowRoot.querySelector("#connect").click();
        console.log("Connnect Clicked - End"); 
    };

    var intervalId = setInterval(clickConnect, 60000);

    var stopClickConnectHandler = function stopClickConnect() {
        console.log("Connnect Clicked Stopped - Start");
        clearInterval(intervalId);
        console.log("Connnect Clicked Stopped - End");
    };

    return stopClickConnectHandler;
};

var stopClickConnect = startClickConnect();

Aby się zatrzymać, zadzwoń:

stopClickConnect();

utwórz kod Pythona na swoim komputerze za pomocą pynput

from pynput.mouse import Button, Controller
import time

mouse = Controller()

while True:
    mouse.click(Button.left, 1)
    time.sleep(30)

Uruchom ten kod na pulpicie, a następnie najedź kursorem myszy na (lewy panel colabs - sekcja plików) strukturę katalogów w dowolnym katalogu, ten kod będzie klikał katalog co 30 sekund, dzięki czemu będzie się rozszerzał i zmniejszał co 30 sekund, aby Twoja sesja nie wygasł Ważne - musisz uruchomić ten kod na swoim komputerze

Zamiast klikać przycisk łączenia, po prostu klikam przycisk komentarza, aby utrzymać moją sesję przy życiu. (Sierpień-2020)

function ClickConnect(){

console.log("Working"); 
document.querySelector("#comments > span").click() 
}
setInterval(ClickConnect,5000)

Używam programu makr, aby okresowo klikać przycisk RAM / Dysk, aby trenować model przez całą noc. Sztuczka polega na skonfigurowaniu programu makr tak, aby dwukrotnie klikał przycisk paska narzędzi Ram / Disk Colab z krótką przerwą między dwoma kliknięciami, tak aby nawet jeśli środowisko wykonawcze zostało odłączone, ponownie się połączyło. (pierwsze kliknięcie służyło do zamknięcia okna dialogowego, a drugie służyło do PONOWNEGO PODŁĄCZENIA). Jednak nadal musisz zostawić laptopa otwartego przez całą noc i może przypiąć kartę Colab.

Powyższe odpowiedzi z pomocą niektórych skryptów mogą działać dobrze. Mam rozwiązanie (lub rodzaj sztuczki) na to irytujące rozłączanie bez skryptów, zwłaszcza gdy twój program musi czytać dane z twojego dysku Google, na przykład trenowanie modelu sieci głębokiego uczenia się, gdzie używanie skryptów do wykonywania reconnectoperacji jest bezużyteczne, ponieważ raz rozłączasz się ze swoją kolumną, program jest po prostu martwy, powinieneś ponownie ręcznie połączyć się z dyskiem Google, aby model mógł ponownie odczytać zestaw danych, ale skrypty tego nie zrobią.
Testowałem to już wiele razy i działa dobrze.
Kiedy uruchamiasz program na stronie colab za pomocą przeglądarki (ja używam Chrome), pamiętaj tylko, że nie wykonuj żadnych operacji w przeglądarce po uruchomieniu programu, takich jak: przełączanie się na inne strony internetowe, otwieranie lub zamykanie innej strony internetowej i tak dalej, po prostu zostaw to w spokoju i czekając na zakończenie działania programu, możesz przełączyć się na inne oprogramowanie, takie jak pycharm, aby nadal zapisywać kody, ale nie przełączać się na inną stronę internetową. Nie wiem, dlaczego otwieranie, zamykanie lub przełączanie się na inne strony spowoduje problem z połączeniem ze stroną colab google, ale za każdym razem, gdy próbuję zawracać sobie głowę przeglądarką, na przykład szukam czegoś, moje połączenie z colab wkrótce się zepsuje.

Spróbuj tego:

function ClickConnect(){
  console.log("Working"); 
  document
    .querySelector("#top-toolbar > colab-connect-button")
    .shadowRoot
    .querySelector("#connect")
    .click()
}

setInterval(ClickConnect,60000)

Korzystanie z selenu Python

from selenium.webdriver.common.keys import Keys
from selenium import webdriver
import time   

driver = webdriver.Chrome('/usr/lib/chromium-browser/chromedriver')

notebook_url = ''
driver.get(notebook_url)

# run all cells
driver.find_element_by_tag_name('body').send_keys(Keys.CONTROL + Keys.F9)
time.sleep(5)

# click to stay connected
start_time = time.time()
current_time = time.time()
max_time = 11*59*60 #12hours

while (current_time - start_time) < max_time:
    webdriver.ActionChains(driver).send_keys(Keys.ESCAPE).perform()
    driver.find_element_by_xpath('//*[@id="top-toolbar"]/colab-connect-button').click()
    time.sleep(30)
    current_time = time.time()

Nie wierzę, że rozwiązania JavaScript już działają. Robiłem to z poziomu mojego notatnika z:

    from IPython.display import display, HTML
    js = ('<script>function ConnectButton(){ '
           'console.log("Connect pushed"); '
           'document.querySelector("#connect").click()} '
           'setInterval(ConnectButton,3000);</script>')
    display(HTML(js))

Kiedy po raz pierwszy wykonujesz polecenie Uruchom wszystko (przed uruchomieniem kodu JavaScript lub Python), konsola wyświetla:

Connected to 
wss://colab.research.google.com/api/kernels/0e1ce105-0127-4758-90e48cf801ce01a3/channels?session_id=5d8...

Jednak za każdym razem, gdy JavaScript działa, widzisz część console.log, ale część dotycząca kliknięcia daje po prostu:

Connect pushed

Uncaught TypeError: Cannot read property 'click' of null
 at ConnectButton (<anonymous>:1:92)

Inni sugerowali, że nazwa przycisku została zmieniona na # colab-connect-button, ale to daje ten sam błąd.

Po uruchomieniu środowiska uruchomieniowego przycisk zmienia się, aby wyświetlić RAM / DYSK, i pojawia się lista rozwijana. Kliknięcie listy rozwijanej tworzy nowy, <DIV class=goog menu...>który nie był wcześniej wyświetlany w DOM, z 2 opcjami „Połącz z hostowanym środowiskiem wykonawczym” i „Połącz z lokalnym środowiskiem wykonawczym”. Jeśli okno konsoli jest otwarte i pokazuje elementy, możesz zobaczyć ten DIV po kliknięciu elementu rozwijanego. Wystarczy przesunąć kursor myszy między dwiema opcjami w nowym oknie, które się pojawi, dodaje dodatkowe elementy do DOM, a gdy tylko mysz straci fokus, są one całkowicie usuwane z DOM, nawet bez klikania.

Wypróbowałem powyższe kody, ale nie zadziałały. Oto mój kod JS do ponownego połączenia.

let interval = setInterval(function(){
let ok = document.getElementById('ok');
if(ok != null){
   console.log("Connect pushed");
ok.click();
}},60000)

Możesz go używać w ten sam sposób (uruchom go na konsoli swojej przeglądarki), aby go uruchomić. Jeśli chcesz zatrzymać skrypt, możesz wejść clearInterval(interval)i chcesz uruchomić go ponownie setInterval(interval).

Mam nadzieję, że to Ci pomoże.

Aktualizacja zakończona. mi to pasuje.

function ClickConnect(){
console.log("Working"); 
document.querySelector("paper-icon-button").click()
}
Const myjob = setInterval(ClickConnect, 60000)

Jeśli to dla was nie działa, spróbujcie to wyczyścić, uruchamiając:

clearInterval(myjob)

Ten działał dla mnie (wygląda na to, że zmienili nazwę klasy przycisku lub identyfikator):

function ClickConnect(){
    console.log("Working"); 
    document.querySelector("colab-connect-button").click() 
}
setInterval(ClickConnect,60000)

Najczęściej głosowana odpowiedź z pewnością działa dla mnie, ale sprawia, że ​​okno Zarządzaj sesją pojawia się raz po raz.
Rozwiązałem to, automatycznie klikając przycisk odświeżania za pomocą konsoli przeglądarki, jak poniżej

function ClickRefresh(){
    console.log("Clicked on refresh button"); 
    document.querySelector("paper-icon-button").click()
}
setInterval(ClickRefresh, 60000)

Zapraszam do dodania więcej fragmentów w tym celu https://gist.github.com/Subangkar/fd1ef276fd40dc374a7c80acc247613e

Być może wiele z poprzednich rozwiązań już nie działa. Na przykład poniższy kod nadal tworzy nowe komórki kodu w Colab, chociaż działa. Niewątpliwie tworzenie zbioru komórek kodu jest niedogodnością. Jeśli w ciągu kilku godzin działania zostanie utworzonych zbyt wiele komórek kodu i zabraknie pamięci RAM, przeglądarka może się zawiesić.

_{Powtarzające się tworzenie komórek kodu -}

function ClickConnect(){
console.log("Working"); 
document.querySelector("colab-toolbar-button").click() 
}setInterval(ClickConnect,60000)

Ale okazało się, że poniższy kod działa, nie powoduje żadnych problemów. W zakładce Notatnik Colab kliknij Ctrl + Shift + ijednocześnie klawisz i wklej poniższy kod w konsoli. 120000 interwałów wystarczy.

function ClickConnect(){
console.log("Working"); 
document.querySelector("colab-toolbar-button#connect").click() 
}setInterval(ClickConnect,120000)

Przetestowałem ten kod w przeglądarce Firefox w listopadzie 2020 roku. Będzie działał również na chrome.

Poleciłbym używanie JQuery (wydaje się, że Co-lab domyślnie zawiera JQuery).

function ClickConnect(){
  console.log("Working");
  $("colab-toolbar-button").click();
}
setInterval(ClickConnect,60000);

Mam problem z tymi funkcjami javascript:

function ClickConnect(){
    console.log("Clicked on connect button"); 
    document.querySelector("colab-connect-button").click()
}
setInterval(ClickConnect,60000)

Drukują „Kliknięty przycisk połączenia” na konsoli, zanim przycisk zostanie faktycznie kliknięty. Jak widać z różnych odpowiedzi w tym wątku, identyfikator przycisku połączenia zmienił się kilka razy od czasu uruchomienia Google Colab. I może to ulec zmianie w przyszłości. Więc jeśli masz zamiar skopiować starą odpowiedź z tego wątku, może to być napisane „Kliknięto przycisk połączenia”, ale w rzeczywistości może tego nie robić. Oczywiście, jeśli kliknięcie nie zadziała, wyświetli się błąd na konsoli, ale co, jeśli nie zobaczysz go przypadkowo? Więc lepiej zrób to:

function ClickConnect(){
    document.querySelector("colab-connect-button").click()
    console.log("Clicked on connect button"); 
}
setInterval(ClickConnect,60000)

I na pewno zobaczysz, czy to naprawdę działa, czy nie.

function ClickConnect()
{
    console.log("Working...."); 
    document.querySelector("paper-button#comments").click()
}
setInterval(ClickConnect,600)

to działało dla mnie, ale używaj mądrze

miłej nauki :)

działa dla mnie NAJNOWSZE rozwiązanie:

function ClickConnect(){
  colab.config
  console.log("Connnect Clicked - Start"); 
  document.querySelector("#top-toolbar > colab-connect-button").shadowRoot.querySelector("#connect").click();
  console.log("Connnect Clicked - End");
};
setInterval(ClickConnect, 60000)

Poniższy javascript działa dla mnie. Kredyty dla @ artur.k.space .

function ColabReconnect() {
    var dialog = document.querySelector("colab-dialog.yes-no-dialog");
    var dialogTitle = dialog && dialog.querySelector("div.content-area>h2");
    if (dialogTitle && dialogTitle.innerText == "Runtime disconnected") {
        dialog.querySelector("paper-button#ok").click();
        console.log("Reconnecting...");
    } else {
        console.log("ColabReconnect is in service.");
    }
}
timerId = setInterval(ColabReconnect, 60000);

W notatniku Colab kliknij jednocześnie Ctrl + Shift + iklawisz. Skopiuj i wklej skrypt w wierszu zachęty. Następnie naciśnij Enterprzed zamknięciem edytora.

W ten sposób funkcja będzie co 60 sekund sprawdzać, czy na ekranie pojawi się okno dialogowe połączenia, a jeśli tak, funkcja kliknie okprzycisk automatycznie.

Cóż, nie jestem facetem od Pythona ani nie wiem, jakie jest rzeczywiste użycie tego „Colaba”, używam go jako systemu kompilacji lol. Skonfigurowałem w nim przekazywanie ssh, a następnie wstawiłem ten kod i po prostu zostawiłem go uruchomionego i tak, działa.

import getpass
authtoken = getpass.getpass()

Ten kod ciągle klika „Odśwież folder” w panelu eksploratora plików.

function ClickRefresh(){
  console.log("Working"); 
  document.querySelector("[icon='colab:folder-refresh']").click()
}
const myjob = setInterval(ClickRefresh, 60000)

GNU Colab pozwala na uruchomienie standardowego trwałego środowiska graficznego na szczycie instancji Colaboratory.

Rzeczywiście zawiera mechanizm, który nie pozwala maszynom umrzeć na biegu jałowym.

Oto demonstracja wideo .

Możesz także użyć Pythona do naciskania klawiszy strzałek. Dodałem też trochę losowości w poniższym kodzie.

from pyautogui import press, typewrite, hotkey
import time
from random import shuffle

array = ["left", "right", "up", "down"]

while True:
    shuffle(array)
    time.sleep(10)
    press(array[0])
    press(array[1])
    press(array[2])
    press(array[3])

Po prostu uruchom poniższy kod za komórką, którą chcesz uruchomić, aby uchronić się przed utratą danych.

!python

Aby wyjść z tego trybu, napisz

exit()

Szukałem rozwiązania, dopóki nie znalazłem Pythona3, który losowo przesuwa mysz w tę iz powrotem i klika, zawsze w tym samym miejscu, ale to wystarczyło, aby oszukać Colaba, że ​​myślę, że jestem aktywny na notebooku i nie rozłączam się.

import numpy as np
import time
import mouse
import threading

def move_mouse():
    while True:
        random_row = np.random.random_sample()*100
        random_col = np.random.random_sample()*10
        random_time = np.random.random_sample()*np.random.random_sample() * 100
        mouse.wheel(1000)
        mouse.wheel(-1000)
        mouse.move(random_row, random_col, absolute=False, duration=0.2)
        mouse.move(-random_row, -random_col, absolute=False, duration = 0.2)
        mouse.LEFT
        time.sleep(random_time)


x = threading.Thread(target=move_mouse)
x.start()

Musisz zainstalować potrzebne pakiety: sudo -H pip3 install <package_name> wystarczy go uruchomić (na komputerze lokalnym) za pomocą sudo(przejmuje kontrolę nad myszą) i powinno działać, umożliwiając pełne wykorzystanie 12-godzinnych sesji Colaba.

Kredyty: dla osób używających Colab (Pro): zapobieganie rozłączaniu sesji z powodu braku aktywności

function ClickConnect(){
    console.log("Clicked on connect button"); 
    document.querySelector("connect").click() // Change id here
}
setInterval(ClickConnect,60000)

Wypróbuj powyższy kod, który zadziałał dla mnie :)