Google Colab: jak odczytać dane z mojego dysku Google?

Problem jest prosty: trochę danych na gDrive mam np /projects/my_project/my_data*. Pod adresem .

Mam też prosty notatnik w gColab.

Chciałbym więc zrobić coś takiego:

for file in glob.glob("/projects/my_project/my_data*"):
    do_something(file)

Niestety, wszystkie przykłady (takie jak ten - na przykład https://colab.research.google.com/notebook#fileId=/v2/external/notebooks/io.ipynb ) sugerują głównie ładowanie wszystkich niezbędnych danych do notebooka.

Ale jeśli mam dużo danych, może to być dość skomplikowane. Czy są jakieś możliwości rozwiązania tego problemu?

Dzięki za pomoc!

Dobra wiadomość, PyDrive ma pierwszorzędne wsparcie w CoLab! PyDrive to opakowanie dla klienta Pythona Dysku Google. Oto przykład, jak pobrać WSZYSTKIE pliki z folderu, podobnie jak przy użyciu glob+ *:

!pip install -U -q PyDrive
import os
from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
from google.colab import auth
from oauth2client.client import GoogleCredentials

# 1. Authenticate and create the PyDrive client.
auth.authenticate_user()
gauth = GoogleAuth()
gauth.credentials = GoogleCredentials.get_application_default()
drive = GoogleDrive(gauth)

# choose a local (colab) directory to store the data.
local_download_path = os.path.expanduser('~/data')
try:
  os.makedirs(local_download_path)
except: pass

# 2. Auto-iterate using the query syntax
#    https://developers.google.com/drive/v2/web/search-parameters
file_list = drive.ListFile(
    {'q': "'1SooKSw8M4ACbznKjnNrYvJ5wxuqJ-YCk' in parents"}).GetList()

for f in file_list:
  # 3. Create & download by id.
  print('title: %s, id: %s' % (f['title'], f['id']))
  fname = os.path.join(local_download_path, f['title'])
  print('downloading to {}'.format(fname))
  f_ = drive.CreateFile({'id': f['id']})
  f_.GetContentFile(fname)


with open(fname, 'r') as f:
  print(f.read())

Zwróć uwagę, że argumenty do drive.ListFileto słownik, który pokrywa się z parametrami używanymi przez interfejs API HTTP usługi Google Drive (możesz dostosować qparametr, aby był dostosowany do Twojego przypadku użycia).

Wiedz, że we wszystkich przypadkach pliki / foldery są kodowane za pomocą identyfikatorów ( zajrzyj do 1SooKSw8M4ACbznKjnNrYvJ5wxuqJ-YCk ) na Dysku Google. Wymaga to przeszukania Dysku Google pod kątem określonego identyfikatora odpowiadającego folderowi, w którym chcesz zakorzenić swoje wyszukiwanie.

Na przykład przejdź do folderu "/projects/my_project/my_data"znajdującego się na Dysku Google.

Zobacz, że zawiera jakieś pliki, w których chcemy pobrać do CoLab. Aby uzyskać identyfikator folderu w celu użycia go przez PyDrive, spójrz na adres URL i wyodrębnij parametr id. W tym przypadku adres URL odpowiadający folderowi był następujący:

Gdzie identyfikator to ostatni element adresu URL: 1SooKSw8M4ACbznKjnNrYvJ5wxuqJ-YCk .

Edycja : od lutego 2020 r. Dostępny jest pierwszorzędny interfejs użytkownika do automatycznego montowania Dysku.

Najpierw otwórz przeglądarkę plików po lewej stronie. Pokaże się przycisk „Zamontuj dysk”. Po kliknięciu zobaczysz monit o pozwolenie na zamontowanie Dysku, a następnie pliki na Dysku będą dostępne bez konfiguracji po powrocie do notebooka. Ukończony przepływ wygląda następująco:

Oryginalna odpowiedź znajduje się poniżej. (Będzie to również działać w przypadku udostępnionych notatników).

Możesz zamontować pliki z Dysku Google, uruchamiając następujący fragment kodu:

from google.colab import drive
drive.mount('/content/drive')

Następnie możesz wchodzić w interakcje z plikami na Dysku w panelu bocznym przeglądarki plików lub za pomocą narzędzi wiersza polecenia.

Oto przykładowy notatnik

Dzięki za świetne odpowiedzi! Najszybszy sposób na pobranie kilku jednorazowych plików do Colab z Dysku Google: Załaduj pomocnika Dysku i zamontuj

from google.colab import drive

Spowoduje to wyświetlenie monitu o autoryzację.

drive.mount('/content/drive')

Otwórz link w nowej karcie -> otrzymasz kod - skopiuj go z powrotem do monitu, w którym masz teraz dostęp do sprawdzenia dysku Google:

!ls "/content/drive/My Drive"

następnie skopiuj plik (i) w razie potrzeby:

!cp "/content/drive/My Drive/xy.py" "xy.py"

potwierdź, że pliki zostały skopiowane:

!ls

Większość poprzednich odpowiedzi jest nieco (bardzo) skomplikowana,

from google.colab import drive
drive.mount("/content/drive", force_remount=True)

Doszedłem do wniosku, że jest to najłatwiejszy i najszybszy sposób na zamontowanie dysku Google w CO Lab.Możesz zmienić mount directory locationto, co chcesz, po prostu zmieniając parametr dla drive.mount. Da ci link do zaakceptowania uprawnień na swoim koncie, a następnie musisz skopiować, wkleić wygenerowany klucz, a następnie dysk zostanie zamontowany w wybranej ścieżce.

force_remount jest używany tylko wtedy, gdy musisz zamontować dysk niezależnie od tego, czy był on wcześniej załadowany.Możesz pominąć ten parametr when jeśli nie chcesz wymusić montowania

Edycja: Sprawdź to, aby znaleźć więcej sposobów wykonywania IOoperacji w colab https://colab.research.google.com/notebooks/io.ipynb

Nie możesz trwale przechowywać pliku na colab. Chociaż możesz importować pliki z dysku i za każdym razem, gdy skończysz z plikiem, możesz go zapisać.

Aby zamontować dysk Google do sesji Colab

from google.colab import drive
drive.mount('/content/gdrive')

możesz po prostu pisać na dysku Google, tak jak w lokalnym systemie plików. Teraz, jeśli zobaczysz, że dysk Google zostanie załadowany na karcie Pliki. Teraz możesz uzyskać dostęp do dowolnego pliku ze swojej kolumny, możesz pisać i czytać z niego. Zmiany zostaną wprowadzone w czasie rzeczywistym na Twoim dysku i każdy, kto ma łącze dostępu do Twojego pliku, będzie mógł przeglądać wprowadzone przez Ciebie zmiany z poziomu Twojej kolumny.

Przykład

with open('/content/gdrive/My Drive/filename.txt', 'w') as f:
   f.write('values')

Najpierw zrobiłem:

from google.colab import drive
drive.mount('/content/drive/')

Następnie

%cd /content/drive/My Drive/Colab Notebooks/

Po tym, jak mogę na przykład czytać pliki csv z rozszerzeniem

df = pd.read_csv("data_example.csv")

Jeśli masz różne lokalizacje plików, po prostu dodaj poprawną ścieżkę po Moim dysku

Jestem leniwy i mam kiepską pamięć, dlatego zdecydowałem się stworzyć easyColab, która jest łatwiejsza do zapamiętania i pisania:

import easycolab as ec
ec.mount()

Najpierw zainstaluj go: !pip install easycolab

mount()Metoda zasadzie zaimplementować to:

from google.colab import drive
drive.mount(‘/content/drive’)
cd ‘/content/gdrive/My Drive/’

Możesz po prostu skorzystać z fragmentów kodu po lewej stronie ekranu. wprowadź opis obrazu tutaj

Wstaw „Montowanie Dysku Google w maszynie wirtualnej”

uruchom kod i skopiuj i wklej kod w adresie URL

a następnie użyj! ls do sprawdzenia katalogów

!ls /gdrive

w większości przypadków znajdziesz to, co chcesz, w katalogu „/ gdrive / My drive”

możesz to zrobić w ten sposób:

from google.colab import drive
drive.mount('/gdrive')
import glob

file_path = glob.glob("/gdrive/My Drive/***.txt")
for file in file_path:
    do_something(file)

Napisałem klasę, która pobiera wszystkie dane do „.” lokalizacja na serwerze colab

Całość można pobrać stąd https://github.com/brianmanderson/Copy-Shared-Google-to-Colab

!pip install PyDrive


from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
from google.colab import auth
from oauth2client.client import GoogleCredentials
import os

class download_data_from_folder(object):
    def __init__(self,path):
        path_id = path[path.find('id=')+3:]
        self.file_list = self.get_files_in_location(path_id)
        self.unwrap_data(self.file_list)
    def get_files_in_location(self,folder_id):
        file_list = drive.ListFile({'q': "'{}' in parents and trashed=false".format(folder_id)}).GetList()
        return file_list
    def unwrap_data(self,file_list,directory='.'):
        for i, file in enumerate(file_list):
            print(str((i + 1) / len(file_list) * 100) + '% done copying')
            if file['mimeType'].find('folder') != -1:
                if not os.path.exists(os.path.join(directory, file['title'])):
                    os.makedirs(os.path.join(directory, file['title']))
                print('Copying folder ' + os.path.join(directory, file['title']))
                self.unwrap_data(self.get_files_in_location(file['id']), os.path.join(directory, file['title']))
            else:
                if not os.path.exists(os.path.join(directory, file['title'])):
                    downloaded = drive.CreateFile({'id': file['id']})
                    downloaded.GetContentFile(os.path.join(directory, file['title']))
        return None
data_path = 'shared_path_location'
download_data_from_folder(data_path)

Aby na przykład wyodrębnić plik ZIP z Dysku Google z notatnika Google Colab:

import zipfile
from google.colab import drive

drive.mount('/content/drive/')

zip_ref = zipfile.ZipFile("/content/drive/My Drive/ML/DataSet.zip", 'r')
zip_ref.extractall("/tmp")
zip_ref.close()

Aby odczytać wszystkie pliki w folderze:

import glob
from google.colab import drive
drive.mount('/gdrive', force_remount=True)

#!ls "/gdrive/My Drive/folder"

files = glob.glob(f"/gdrive/My Drive/folder/*.txt")
for file in files:  
  do_something(file)

@wenkesj

Mowa o skopiowaniu katalogu i wszystkich jego podkatalogów.

U mnie znalazłem rozwiązanie, które wygląda tak:

def copy_directory(source_id, local_target):
  try:
    os.makedirs(local_target)
  except: 
    pass
  file_list = drive.ListFile(
    {'q': "'{source_id}' in parents".format(source_id=source_id)}).GetList()
  for f in file_list:
    key in ['title', 'id', 'mimeType']]))
    if f["title"].startswith("."):
      continue
    fname = os.path.join(local_target, f['title'])
    if f['mimeType'] == 'application/vnd.google-apps.folder':
      copy_directory(f['id'], fname)
    else:
      f_ = drive.CreateFile({'id': f['id']})
      f_.GetContentFile(fname)

Niemniej jednak wygląda na to, że gDrive nie lubi kopiować zbyt wielu plików.

Istnieje wiele sposobów odczytywania plików w notatniku colab (**. Ipnb), kilka z nich to:

1. Montowanie Dysku Google na maszynie wirtualnej środowiska wykonawczego. tutaj i tutaj
2. Korzystanie z google.colab.files.upload (). najłatwiejsze rozwiązanie
3. Korzystanie z natywnego interfejsu API REST ;
4. Używanie otoki wokół API, takiej jak PyDrive

Metoda 1 i 2 zadziałała dla mnie , reszty nie byłem w stanie rozgryźć. Jeśli ktokolwiek mógł, jak inni próbowali w powyższym poście, napisz elegancką odpowiedź. z góry dziękuję.!

Pierwsza metoda:

Nie udało mi się zamontować dysku Google, więc zainstalowałem te biblioteki

# Install a Drive FUSE wrapper.
# https://github.com/astrada/google-drive-ocamlfuse

!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse

from google.colab import auth
auth.authenticate_user()
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass

!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}

Po zakończeniu procesu instalacji i autoryzacji najpierw montujesz dysk.

!mkdir -p drive
!google-drive-ocamlfuse drive

Po instalacji udało mi się zamontować dysk Google, wszystko na twoim dysku Google zaczyna się od / content / drive

!ls /content/drive/ML/../../../../path_to_your_folder/

Teraz możesz po prostu wczytać plik z path_to_your_folderfolderu do pandy, korzystając z powyższej ścieżki.

import pandas as pd
df = pd.read_json('drive/ML/../../../../path_to_your_folder/file.json')
df.head(5)

przypuszczasz, że używasz otrzymanej ścieżki bezwzględnej i nie używasz /../ ..

Druga metoda :

Co jest wygodne, jeśli plik, który chcesz przeczytać, znajduje się w bieżącym katalogu roboczym.

Jeśli chcesz przesłać jakiekolwiek pliki z lokalnego systemu plików, możesz użyć poniższego kodu, w przeciwnym razie po prostu tego unikaj.!

from google.colab import files
uploaded = files.upload()
for fn in uploaded.keys():
  print('User uploaded file "{name}" with length {length} bytes'.format(
      name=fn, length=len(uploaded[fn])))

załóżmy, że masz poniżej hierarchii folderów na dysku Google:

/content/drive/ML/../../../../path_to_your_folder/

Następnie wystarczy poniższy kod, aby załadować do pand.

import pandas as pd
import io
df = pd.read_json(io.StringIO(uploaded['file.json'].decode('utf-8')))
df

from google.colab import drive
drive.mount('/content/drive')

To zadziałało idealnie dla mnie. Później mogłem korzystać z osbiblioteki, aby uzyskać dostęp do moich plików, tak jak mam do nich dostęp na moim komputerze

Rozważ po prostu pobranie pliku ze stałym łączem i gdownpreinstalacji, tak jak tutaj