def titanic_data_download(path: str, predict_size: float = 0.1) -> None:
if not os.path.exists(path):
os.makedirs(path)
path_data = os.path.join(path, "titanic.csv")
download_data("https://pl-flash-data.s3.amazonaws.com/titanic.csv",
path_data)
if set(os.listdir(path)) != {"predict.csv", "titanic.csv"}:
assert 0 < predict_size < 1
df = pd.read_csv(path_data)
df_train, df_predict = train_test_split(df, test_size=predict_size)
df_train.to_csv(path_data)
df_predict = df_predict.drop(columns=["Survived"])
df_predict.to_csv(os.path.join(path, "predict.csv"))
import torch
from torch.utils.data.sampler import RandomSampler
import flash
from flash.core.classification import Labels
from flash.core.finetuning import NoFreeze
from flash.data.utils import download_data
from flash.utils.imports import _KORNIA_AVAILABLE, _PYTORCHVIDEO_AVAILABLE
from flash.video import VideoClassificationData, VideoClassifier
if _PYTORCHVIDEO_AVAILABLE and _KORNIA_AVAILABLE:
import kornia.augmentation as K
from pytorchvideo.transforms import ApplyTransformToKey, RandomShortSideScale, UniformTemporalSubsample
from torchvision.transforms import CenterCrop, Compose, RandomCrop, RandomHorizontalFlip
else:
print("Please, run `pip install torchvideo kornia`")
sys.exit(0)
# 1. Download a video clip dataset. Find more dataset at https://pytorchvideo.readthedocs.io/en/latest/data.html
download_data("https://pl-flash-data.s3.amazonaws.com/kinetics.zip")
model = VideoClassifier.load_from_checkpoint(
"https://flash-weights.s3.amazonaws.com/video_classification.pt",
pretrained=False)
# 2. Make a prediction
predict_folder = "data/kinetics/predict/"
predictions = model.predict(
[os.path.join(predict_folder, f) for f in os.listdir(predict_folder)])
print(predictions)
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from torchmetrics.classification import Accuracy, Precision, Recall
import flash
from flash.data.utils import download_data
from flash.tabular import TabularClassifier, TabularData
# 1. Download the data
download_data("https://pl-flash-data.s3.amazonaws.com/titanic.zip", "data/")
# 2. Load the data
datamodule = TabularData.from_csv(
["Sex", "Age", "SibSp", "Parch", "Ticket", "Cabin", "Embarked"],
["Fare"],
target_field="Survived",
train_file="./data/titanic/titanic.csv",
test_file="./data/titanic/test.csv",
val_split=0.25,
)
# 3. Build the model
model = TabularClassifier.from_data(
datamodule, metrics=[Accuracy(), Precision(),
Recall()])
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from flash import Trainer
from flash.data.utils import download_data
from flash.vision import ImageClassificationData, ImageClassifier
# 1. Download the data
download_data("https://pl-flash-data.s3.amazonaws.com/hymenoptera_data.zip",
"data/")
# 2. Load the model from a checkpoint
model = ImageClassifier.load_from_checkpoint(
"https://flash-weights.s3.amazonaws.com/image_classification_model.pt")
# 3a. Predict what's on a few images! ants or bees?
predictions = model.predict([
"data/hymenoptera_data/val/bees/65038344_52a45d090d.jpg",
"data/hymenoptera_data/val/bees/590318879_68cf112861.jpg",
"data/hymenoptera_data/val/ants/540543309_ddbb193ee5.jpg",
])
print(predictions)
# 3b. Or generate predictions with a whole folder!
datamodule = ImageClassificationData.from_folders(
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import torch
import flash
from flash.data.utils import download_data
from flash.text import TranslationData, TranslationTask
# 1. Download the data
download_data("https://pl-flash-data.s3.amazonaws.com/wmt_en_ro.zip", "data/")
# 2. Load the data
datamodule = TranslationData.from_files(
train_file="data/wmt_en_ro/train.csv",
val_file="data/wmt_en_ro/valid.csv",
test_file="data/wmt_en_ro/test.csv",
input="input",
target="target",
batch_size=1
)
# 3. Build the model
model = TranslationTask()
# 4. Create the trainer
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import pytorch_lightning as pl
from torch import nn, optim
from torch.utils.data import DataLoader, random_split
from torchvision import datasets, transforms
from flash.core.classification import ClassificationTask
from flash.data.utils import download_data
_PATH_ROOT = os.path.dirname(os.path.dirname(__file__))
# 1. Download the data
download_data("https://www.di.ens.fr/~lelarge/MNIST.tar.gz",
os.path.join(_PATH_ROOT, 'data'))
# 2. Load a basic backbone
model = nn.Sequential(
nn.Flatten(),
nn.Linear(28 * 28, 128),
nn.ReLU(),
nn.Linear(128, 10),
)
# 3. Load a dataset
dataset = datasets.MNIST(os.path.join(_PATH_ROOT, 'data'),
download=False,
transform=transforms.ToTensor())
# 4. Split the data randomly
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import flash
from flash.data.utils import download_data
from flash.vision import SemanticSegmentation, SemanticSegmentationData
from flash.vision.segmentation.serialization import SegmentationLabels
# 1. Download the data
# This is a Dataset with Semantic Segmentation Labels generated via CARLA self-driving simulator.
# The data was generated as part of the Lyft Udacity Challenge.
# More info here: https://www.kaggle.com/kumaresanmanickavelu/lyft-udacity-challenge
download_data(
"https://github.com/ongchinkiat/LyftPerceptionChallenge/releases/download/v0.1/carla-capture-20180513A.zip", "data/"
)
# 2.1 Load the data
datamodule = SemanticSegmentationData.from_folders(
train_folder="data/CameraRGB",
train_target_folder="data/CameraSeg",
batch_size=4,
val_split=0.3,
image_size=(200, 200), # (600, 800)
)
# 2.2 Visualise the samples
labels_map = SegmentationLabels.create_random_labels_map(num_classes=21)
datamodule.set_labels_map(labels_map)
datamodule.show_train_batch(["load_sample", "post_tensor_transform"])
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import flash
from flash.data.utils import download_data
from flash.vision import ObjectDetectionData, ObjectDetector
# 1. Download the data
# Dataset Credit: https://www.kaggle.com/ultralytics/coco128
download_data(
"https://github.com/zhiqwang/yolov5-rt-stack/releases/download/v0.3.0/coco128.zip",
"data/")
# 2. Load the Data
datamodule = ObjectDetectionData.from_coco(
train_folder="data/coco128/images/train2017/",
train_ann_file="data/coco128/annotations/instances_train2017.json",
batch_size=2,
)
# 3. Build the model
model = ObjectDetector(num_classes=datamodule.num_classes)
# 4. Create the trainer
trainer = flash.Trainer(max_epochs=3, limit_train_batches=1)
def test_download_data(tmpdir):
path = os.path.join(tmpdir, "data")
download_data("https://pl-flash-data.s3.amazonaws.com/titanic.zip", path)
assert set(os.listdir(path)) == {'titanic', 'titanic.zip'}
from typing import List, Tuple
import pandas as pd
from torchmetrics import F1
import flash
from flash.core.classification import Labels
from flash.data.utils import download_data
from flash.vision import ImageClassificationData, ImageClassifier
from flash.vision.classification.data import ImageClassificationPreprocess
# 1. Download the data
# This is a subset of the movie poster genre prediction data set from the paper
# “Movie Genre Classification based on Poster Images with Deep Neural Networks” by Wei-Ta Chu and Hung-Jui Guo.
# Please consider citing their paper if you use it. More here: https://www.cs.ccu.edu.tw/~wtchu/projects/MoviePoster/
download_data("https://pl-flash-data.s3.amazonaws.com/movie_posters.zip", "data/")
# 2. Load the data
genres = ["Action", "Romance", "Crime", "Thriller", "Adventure"]
def load_data(data: str, root: str = 'data/movie_posters') -> Tuple[List[str], List[List[int]]]:
metadata = pd.read_csv(osp.join(root, data, "metadata.csv"))
return ([osp.join(root, data, row['Id'] + ".jpg") for _, row in metadata.iterrows()],
[[int(row[genre]) for genre in genres] for _, row in metadata.iterrows()])
train_filepaths, train_labels = load_data('train')
test_filepaths, test_labels = load_data('test')
datamodule = ImageClassificationData.from_filepaths(
