-
{makeTaskTitle(props)} to {task.inputText.toLowerCase()}
+
{makeTaskTitle(props)} to {inputText.toLowerCase()}
{sampleInputs.map(makeSampleInput)}
diff --git a/src/components/Experiment/QuickInput/Tabs/SampleInput/useSampleInputControl.js b/src/components/Experiment/QuickInput/Tabs/SampleInput/useSampleInputControl.js
index f959ae4f..dbce9059 100644
--- a/src/components/Experiment/QuickInput/Tabs/SampleInput/useSampleInputControl.js
+++ b/src/components/Experiment/QuickInput/Tabs/SampleInput/useSampleInputControl.js
@@ -1,16 +1,47 @@
import {useState} from "react";
import {QuickInputType} from "../../quickInputType";
+import Task from "../../../../../helpers/Task";
export default function useSampleInputControl(props) {
+ const task = Task.getStaticTask(props.task);
+
const [selectedIndex, setSelectedIndex] = useState([]);
const isSelected = (input) => props.type === QuickInputType.Image ? selectedIndex.indexOf(input.src) > -1 : selectedIndex.indexOf(input) > -1;
const isUnselected = (input) => selectedIndex.length >= 0 && props.type === QuickInputType.Image ? selectedIndex.indexOf(input.src) === -1 : selectedIndex.indexOf(input) === -1;
+ const selectMultiInput = (selectedValueIndex) => {
+ // Note: Currently using both new and old way of handling inputs but should refactor in the future
+ let input = props.type === QuickInputType.Image ?
+ props.sampleInputs[props.inputIndex][selectedValueIndex].src :
+ props.sampleInputs[props.inputIndex][selectedValueIndex];
+
+ if (props.multiple) {
+ // TODO: This block was directly copied from selectInput and needs to be
+ // updated for useMultiInput
+
+ // const selected = Array.from(selectedIndex);
+ // let storedIndex = selected.indexOf(input);
+ // if (storedIndex === -1) {
+ // selected.push(input);
+ // } else {
+ // selected.splice(storedIndex, 1);
+ // }
+ // setSelectedIndex(selected);
+ // if (typeof (props.inputSelected) === 'function')
+ // props.inputSelected(selected);
+ } else {
+ setSelectedIndex([input]);
+ if (typeof(props.inputSelected) === 'function')
+ // Note: props.inputSelected is useQuickInputControl.selectMultiInput
+ props.inputSelected(input, props.inputIndex);
+ }
+ }
+
const selectInput = (index) => {
- const input = props.type === QuickInputType.Image ?
- props.sampleInputs[index].src :
- props.sampleInputs[index];
+ const input = props.type === QuickInputType.Image ?
+ props.sampleInputs[index].src :
+ props.sampleInputs[index];
if (props.multiple) {
const selected = Array.from(selectedIndex);
@@ -32,5 +63,10 @@ export default function useSampleInputControl(props) {
const {type} = props;
- return {selectedIndex, selectInput, isSelected, isUnselected, type};
+ return {
+ selectedIndex,
+ selectInput: !task.useMultiInput ? selectInput : selectMultiInput,
+ isSelected,
+ isUnselected,
+ type};
}
diff --git a/src/components/Experiment/QuickInput/Tabs/URLInput/URLInputsTab.js b/src/components/Experiment/QuickInput/Tabs/URLInput/URLInputsTab.js
index 5e3d7e2f..abfe9e78 100644
--- a/src/components/Experiment/QuickInput/Tabs/URLInput/URLInputsTab.js
+++ b/src/components/Experiment/QuickInput/Tabs/URLInput/URLInputsTab.js
@@ -9,32 +9,63 @@ export default function URLInputsTab(props) {
const {getBlock, getElement} = useBEMNaming("url-inputs");
const {urlChanged, getUrlValidity, task, values} = useURLInputControl(props);
const taskName = task.inputType.toLowerCase();
+ // Note: Currently using both new and old way of handling inputs but should refactor in the future
+ const inputText = task.inputText || props.input.inputText;
const getInputClassName = (index) => getElement(getUrlValidity(index) ? "url url-error" : "url")
return (
-
- Copy an {taskName} URL ({taskName} address) and paste
- {" "}to {task.inputText.toLowerCase()}
-
- {(values).map((value, index) => (
-
-
urlChanged(e, index)}
- />
- {getUrlValidity(index) &&
-
- Not a valid URL. Right click on an {taskName} to copy the {taskName}
- address.
-
}
-
+ {
+ task.useMultiInput ? (
+ <>
+
+ Copy an {taskName} URL ({taskName} address) and paste
+ {" "}to {inputText.toLowerCase()}
+
+
+
+
urlChanged(e, props.inputIndex)}
+ />
+ {getUrlValidity(props.inputIndex) &&
+
+ Not a valid URL. Right click on an {taskName} to copy the {taskName}
+ address.
+
}
+
+
+ ) : (
+ <>
+
+ Copy an {taskName} URL ({taskName} address) and paste
+ {" "}to {inputText.toLowerCase()}
+
+ {(values).map((value, index) => (
+
+
urlChanged(e, index)}
+ />
+ {getUrlValidity(index) &&
+
+ Not a valid URL. Right click on an {taskName} to copy the {taskName}
+ address.
+
}
+
+ )
+ )}
+ {props.multiple &&
}
+
)
- )}
- {props.multiple &&
}
+ }
+
+
);
}
diff --git a/src/components/Experiment/QuickInput/Tabs/URLInput/useURLInputControl.js b/src/components/Experiment/QuickInput/Tabs/URLInput/useURLInputControl.js
index 543ec850..afb4a792 100644
--- a/src/components/Experiment/QuickInput/Tabs/URLInput/useURLInputControl.js
+++ b/src/components/Experiment/QuickInput/Tabs/URLInput/useURLInputControl.js
@@ -24,8 +24,20 @@ export default function useURLInputControl(props) {
setIsInvalidUrl(currentInvalidUrl);
if (typeof (props.inputSelected) === 'function') {
+ // console.log('about to set inputSelected..')
+ // console.log('isInvalidUrl', isInvalidUrl)
+ // if (isInvalidUrl[index]) {
+ // console.log('this url is invalid....')
+ // console.log(isInvalidUrl[index])
+ // } else {
+ // console.log('this url is valid....')
+ // console.log(isInvalidUrl[index])
+ // props.inputSelected(url, index);
+ // }
+
+
+ // Todo: How to not add this to inputSelected if invalid url?
props.inputSelected(url, index);
-
}
}
diff --git a/src/components/Experiment/QuickInput/Tabs/UploadInput/UploadInputsTab.js b/src/components/Experiment/QuickInput/Tabs/UploadInput/UploadInputsTab.js
index 0a65afcc..ebdc333c 100644
--- a/src/components/Experiment/QuickInput/Tabs/UploadInput/UploadInputsTab.js
+++ b/src/components/Experiment/QuickInput/Tabs/UploadInput/UploadInputsTab.js
@@ -16,10 +16,12 @@ export default function UploadInputsTab(props) {
const task = Task.getStaticTask(props.task);
const taskName = task.inputType.toLowerCase();
+ // Currently using both new and old way of handling inputs but should refactor in the future
+ const inputText = task.inputText || props.input.inputText;
return (
-
Upload an {taskName} file to {task.inputText.toLowerCase()}
+
Upload an {taskName} file to {inputText.toLowerCase()}
);
diff --git a/src/components/Experiment/QuickInput/Tabs/UploadInput/useUploadInputControl.js b/src/components/Experiment/QuickInput/Tabs/UploadInput/useUploadInputControl.js
index 8c341ae8..f751131d 100644
--- a/src/components/Experiment/QuickInput/Tabs/UploadInput/useUploadInputControl.js
+++ b/src/components/Experiment/QuickInput/Tabs/UploadInput/useUploadInputControl.js
@@ -4,9 +4,19 @@ import AwsS3Multipart from "@uppy/aws-s3-multipart";
import {useEffect, useMemo, useState} from "react";
import UppyFileTypeCheckerPlugin from "../../../../../helpers/UppyFileTypeCheckerPlugin";
+import Task from "../../../../../helpers/Task";
export const useUploadInputControl = (props) => {
+ const task = Task.getStaticTask(props.task);
+
const [activeUser, setActiveUser] = useState("anonymous");
+ const [initialUppy, setInitialUppy] = useState(null);
+
+ useEffect(() => {
+ // Note: useMemo only saves the value once, during the inital render,
+ // but we need onComplete to update with new values for multiInput tasks
+ initialUppy.on("complete", onComplete);
+ }, [props.values])
const onBeforeUpload = (files) => {
Object.keys(files).forEach(key => {
@@ -21,19 +31,29 @@ export const useUploadInputControl = (props) => {
}
const onComplete = (result) => {
+ // COMMENT THIS OUT BEFORE COMMITTING
+ // Note: Uncomment in order to test w/o server, adding a fake uploadURL:
+ // result.successful.map(x => x.uploadURL = `test_${props.inputIndex}.com`)
+
const urls = result.successful.map(x => x.uploadURL);
- if (typeof (props.inputSelected) === 'function') {
- let values = Array.from(props.values);
- if (values.length === 0 || values[0] === "")
- values = urls;
- else
- values = [...values, ...urls];
- props.inputSelected(values);
+ if (!task.useMultiInput) {
+ if (typeof (props.inputSelected) === 'function') {
+ let values = Array.from(props.values);
+ if (values.length === 0 || values[0] === "")
+ values = urls;
+ else
+ values = [...values, ...urls];
+
+ props.inputSelected(values);
+ }
+ } else {
+ if (typeof (props.inputSelected) === 'function') {
+ props.inputSelected(urls[0], props.inputIndex);
+ }
}
}
-
const api = GetApiHelper();
const uppy = useMemo(() => {
let u = Uppy({
@@ -47,6 +67,8 @@ export const useUploadInputControl = (props) => {
onBeforeUpload: onBeforeUpload
});
+ // UNCOMMENT THIS BEFORE COMMITTING
+ // Note: Comment this out in order to test w/o server
u.use(AwsS3Multipart, {
limit: 5,
companionUrl: process.env.REACT_APP_COMPANION_URL
@@ -56,7 +78,7 @@ export const useUploadInputControl = (props) => {
// extentions from being maliciously uploaded
u.use(UppyFileTypeCheckerPlugin, {allowedFileTypes: props.allowedFileTypes.fileTypes});
- u.on("complete", onComplete);
+ setInitialUppy(u);
return u;
}, [])
diff --git a/src/components/Experiment/QuickInput/useQuickInputControl.js b/src/components/Experiment/QuickInput/useQuickInputControl.js
index 4ddc3e28..d92b9ec6 100644
--- a/src/components/Experiment/QuickInput/useQuickInputControl.js
+++ b/src/components/Experiment/QuickInput/useQuickInputControl.js
@@ -1,4 +1,4 @@
-import {useState} from "react";
+import {useEffect, useState} from "react";
import SampleInputsTab from "./Tabs/SampleInput/SampleInputsTab";
import UploadInputsTab from "./Tabs/UploadInput/UploadInputsTab";
import AudioInputTab from "./Tabs/AudioInput/AudioInputTab";
@@ -7,11 +7,19 @@ import clone from "../../../helpers/cloner";
import {QuickInputType} from "./quickInputType";
import TextInputTab from "./Tabs/TextInput/TextInputTab";
import UploadTextInputTab from "./Tabs/UploadTextInput/UploadTextInputTab";
+import Task from "../../../helpers/Task";
export default function useQuickInputControl(props) {
+ const task = Task.getStaticTask(props.model.output.type);
+
const [selectedInputs, setSelectedInputs] = useState([""]);
const [selectedTab, setSelectedTab] = useState(0);
+ // Note: Uncomment for debugging
+ // useEffect(() => {
+ // console.log('selectedInputs', selectedInputs)
+ // }, [selectedInputs])
+
const getTabs = (type = QuickInputType.Image) => { // TODO: Remove this default
const sample = {
id: 'sample-input',
@@ -63,12 +71,24 @@ export default function useQuickInputControl(props) {
}
const selectInput = (url, index) => {
let selected = selectedInputs;
+
if (index)
selected[index] = url;
else
selected = Array.isArray(url) ? url : [url];
setSelectedInputs(selected);
}
+ const selectMultiInput = (url, inputIndex) => {
+ let selected = [...selectedInputs];
+
+ if (inputIndex >= 0)
+ selected[inputIndex] = url;
+ else
+ selected = Array.isArray(url) ? url : [url];
+ // Note: Need to use a useEffect to accurately see what selectedInputs is
+ setSelectedInputs(selected);
+ }
+
const addInput = (url = "") => {
let state = clone(selectedInputs);
if (typeof url !== "string") url = "";
@@ -88,5 +108,14 @@ export default function useQuickInputControl(props) {
const tabIsSelected = (index) => selectedTab === index;
- return {selectedInputs, getTabs, runModel, selectInput, addInput, removeInput, selectTab, tabIsSelected};
+ return {
+ selectedInputs,
+ getTabs,
+ runModel,
+ selectInput: !task.useMultiInput ? selectInput : selectMultiInput,
+ addInput,
+ removeInput,
+ selectTab,
+ tabIsSelected
+ };
}
diff --git a/src/components/Experiment/QuickOutput/InputPreview.scss b/src/components/Experiment/QuickOutput/InputPreview.scss
index 16b0dd65..db86a037 100644
--- a/src/components/Experiment/QuickOutput/InputPreview.scss
+++ b/src/components/Experiment/QuickOutput/InputPreview.scss
@@ -1,6 +1,6 @@
@import "../../../App";
-.input-preview {
+.input-preview, .multi-input-preview {
background-color: white;
border-radius: 5px;
box-shadow: 0 0 15px -2px rgba(0, 0, 0, 0.25);
diff --git a/src/components/Experiment/QuickOutput/MultiInputPreview.js b/src/components/Experiment/QuickOutput/MultiInputPreview.js
new file mode 100644
index 00000000..26bdbe17
--- /dev/null
+++ b/src/components/Experiment/QuickOutput/MultiInputPreview.js
@@ -0,0 +1,51 @@
+import React from "react";
+import "./InputPreview.scss";
+import useBEMNaming from "../../../common/useBEMNaming";
+
+const defaultProps = {
+ className: "multi-input-preview",
+ inputs: [],
+ onBackClicked: () => {},
+};
+
+export default function MultiInputPreview(givenProps) {
+ const props = { ...defaultProps, ...givenProps };
+ const { getBlock, getElement } = useBEMNaming(props.className);
+
+ const getInputs = (input) => {
+ switch (input.inputType) {
+ case "text":
+ return
{input}
;
+ case "audio": // Currently not being used
+ case "image":
+ default:
+ return (
+
+ );
+ }
+ };
+
+ return (
+
+
+ Inputs
+
+
+ {
+ props.inputs.map((input, index) => (
+
+ {getInputs(input)}
+
+ )
+ )}
+
+
+
+
+ );
+}
diff --git a/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/StyleTransfer.scss b/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/StyleTransfer.scss
new file mode 100644
index 00000000..15ce859f
--- /dev/null
+++ b/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/StyleTransfer.scss
@@ -0,0 +1,79 @@
+@import "../../../../../App";
+
+.style-transfer {
+ &__content {
+ display: flex;
+ flex-direction: row;
+
+ .multi-input-preview {
+ flex-grow: 1;
+ &__container {
+ display: flex;
+ flex-direction: column;
+ img {
+ margin-bottom: 16px;
+ max-width: 300px;
+ }
+ @include maxWidth(700px) {
+ flex-direction: row;
+ justify-content: space-between;
+ img {
+ max-height: 200px;
+ }
+ }
+ }
+ }
+ @include maxWidth(700px) {
+ display: flex;
+ flex-direction: column;
+ }
+ }
+ &__output {
+ flex-grow: 1;
+ background-color: white;
+ border-radius: 5px;
+ box-shadow: 0 0 15px -2px rgba(0, 0, 0, 0.25);
+ display: flex;
+ flex-direction: column;
+ margin-left: 16px;
+ padding: 32px;
+
+ @include maxWidth(700px) {
+ margin-left: 0;
+ }
+
+ &-title-row {
+ margin-bottom: 0;
+
+ display: flex;
+ flex-direction: row;
+ justify-content: space-between;
+ align-items: center;
+ width: 100%;
+
+ @include maxWidth(575px) {
+ h3 {
+ margin-top: 8px;
+ }
+ }
+ }
+ &-subtitle {
+ @include body;
+ border-bottom: 1px solid $smokeDarkest;
+ margin-bottom: 24px;
+ padding-bottom: 16px;
+
+ @include mobileWidth-lg {
+ @include bodySmall;
+ }
+ }
+ &-image {
+ display: flex;
+ justify-content: center;
+ margin-bottom: 16px;
+ img {
+ width: 70%;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/StyleTransfer.stories.js b/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/StyleTransfer.stories.js
new file mode 100644
index 00000000..0629be43
--- /dev/null
+++ b/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/StyleTransfer.stories.js
@@ -0,0 +1,15 @@
+import React from 'react';
+import StyleTransfer from "./StyleTransferOutput";
+import { TestStyleTransferOutput } from './testData/testStyleTransferOutput';
+
+export default {
+ title: "Experiments/Quick Output/Style Transfer",
+ component: StyleTransfer
+}
+
+const Template = (args) =>
+
+export const Default = Template.bind({});
+
+Default.args = {trial: TestStyleTransferOutput};
+
diff --git a/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/StyleTransferOutput.js b/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/StyleTransferOutput.js
new file mode 100644
index 00000000..b56489bc
--- /dev/null
+++ b/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/StyleTransferOutput.js
@@ -0,0 +1,52 @@
+import React from "react";
+
+import useBEMNaming from "../../../../../common/useBEMNaming";
+import Task from "../../../../../helpers/Task";
+import { styleTransfer } from "../../../../../helpers/TaskIDs";
+
+import MultiInputPreview from "../../MultiInputPreview";
+import Rating from "../Classification/Rating";
+import OutputDuration from "../_Common/components/OutputDuration";
+
+import "./StyleTransfer.scss";
+
+
+export default function StyleTransferOutput(props) {
+ const { getElement, getBlock } = useBEMNaming('style-transfer');
+
+ const task = Task.getStaticTask(styleTransfer);
+
+ const inputs = props.trial?.inputs ?? [];
+ const output = props.trial?.results?.responses[0]?.features[0] ?? {};
+ const duration = props.trial?.results?.duration_for_inference ?? "0s";
+
+
+ return (
+
+
+
+
+
+
+
+
+
Output
+
+
+
+ {task.outputText}
+
+
+
+
+
+
+
+
+
+ )
+}
diff --git a/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/testData/TestFeatures.js b/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/testData/TestFeatures.js
new file mode 100644
index 00000000..124b34aa
--- /dev/null
+++ b/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/testData/TestFeatures.js
@@ -0,0 +1,94 @@
+import ImageEnhancement2 from '../../../../../../resources/img/img-enh2.jpeg'
+
+const testOutput1 = "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";
+
+const testOutput2 = "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";
+
+function makeTestData(input, output) {
+ return {
+ "id": "5945642e-88fc-4278-81a6-6bb49161d671",
+ "inputs": [
+ input
+ ],
+ "completed_at": "2022-05-03T17:00:47.17038Z",
+ "results": {
+ "duration": "492.161067ms",
+ "duration_for_inference": "368.568412ms",
+ "responses": [
+ {
+
+ "features": [
+ {
+ "id": "62715fbfbf8e2400012af957",
+ "probability": 0,
+ "type": "RAW_IMAGE",
+ "raw_image": {
+ "channels": 3,
+ "char_list": null,
+ "data_type": "float32",
+ "float_list": null,
+ "height": 620,
+ "jpeg_data": output,
+ "width": 1100
+ }
+ }
+ ]
+ }
+ ],
+ "trace_id": {}
+ },
+ "model": {
+ "id": 106,
+ "created_at": "2022-04-29T20:47:54.166917Z",
+ "updated_at": "2022-04-29T20:47:54.166917Z",
+ "attributes": {
+ "Top1": "",
+ "Top5": "",
+ "kind": "CNN",
+ "manifest_author": "Yen-Hsiang Chang",
+ "training_dataset": "VOC"
+ },
+ "description": "This model is a replication of the model described in the SRGAN publication.\n",
+ "short_description": "SRGAN is a generative adversarial network for single image super-resolution.",
+ "model": {
+ "graph_checksum": "4527947ddf80f3da2bc9a216b6fb813b",
+ "graph_path": "https://s3.amazonaws.com/store.carml.org/models/onnxruntime/srgan.onnx",
+ "weights_checksum": "",
+ "weights_path": ""
+ },
+ "framework": {
+ "id": 2,
+ "name": "Onnxruntime",
+ "version": "1.6.0",
+ "architectures": [
+ {
+ "name": "amd64"
+ }
+ ]
+ },
+ "input": {
+ "description": "",
+ "type": ""
+ },
+ "license": "unrestricted",
+ "name": "SRGAN",
+ "output": {
+ "description": "the output image",
+ "type": "image_enhancement"
+ },
+ "url": {
+ "github": "https://github.com/eriklindernoren/PyTorch-GAN/blob/master/implementations/srgan/srgan.py",
+ "citation": "https://arxiv.org/abs/1609.04802",
+ "link1": "https://github.com/brade31919/SRGAN-tensorflow",
+ "link2": ""
+ },
+ "version": "1.0"
+ }
+
+
+ }
+}
+
+export const TestImageEnhancementData = makeTestData("https://s3.amazonaws.com/uploads.staging.mlmodelscope.org/birdy.png", testOutput1);
+
+export const TestImageEnhancementData2 = makeTestData(ImageEnhancement2, testOutput2);
diff --git a/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/testData/testStyleTransferOutput.js b/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/testData/testStyleTransferOutput.js
new file mode 100644
index 00000000..bbb9de77
--- /dev/null
+++ b/src/components/Experiment/QuickOutput/Outputs/StyleTransfer/testData/testStyleTransferOutput.js
@@ -0,0 +1,33 @@
+export const TestStyleTransferOutputGeneratedToken = {
+ id: "sampleStyleTransferIdHere"
+};
+
+export const TestStyleTransferOutput = {
+ id: "sampleStyleTransferOutputIdHere",
+ inputs: [
+ {
+ src: "https://s3.amazonaws.com/uploads.staging.mlmodelscope.org/plane-blue.jpg",
+ alt: "airplane",
+ },
+ {
+ src: "https://s3.amazonaws.com/uploads.staging.mlmodelscope.org/puppies.jpg",
+ alt: "puppies",
+ },
+ ],
+ completed_at: "2023-06-03T18:17:14.513854Z",
+ results: {
+ 'duration': "9.216154124s",
+ 'duration_for_inference': "9.193807904s",
+ 'responses': [
+ {
+ 'features': [
+ {
+ src: "https://s3.amazonaws.com/uploads.staging.mlmodelscope.org/birdy.png",
+ alt: "bird",
+ },
+ ],
+ 'id': "sampleStyleTransferOutputResponseIdHere"
+ }
+ ]
+ }
+}
\ No newline at end of file
diff --git a/src/components/Experiment/QuickOutput/Outputs/Text/useTextOutput.js b/src/components/Experiment/QuickOutput/Outputs/Text/useTextOutput.js
index 2135b8ab..3314d757 100644
--- a/src/components/Experiment/QuickOutput/Outputs/Text/useTextOutput.js
+++ b/src/components/Experiment/QuickOutput/Outputs/Text/useTextOutput.js
@@ -33,8 +33,6 @@ export default function useTextOutput(trial) {
}
};
-
-
return {
output: getOutput(),
input,
diff --git a/src/components/Experiment/QuickOutput/QuickOutput.js b/src/components/Experiment/QuickOutput/QuickOutput.js
index 965ad9df..8f197019 100644
--- a/src/components/Experiment/QuickOutput/QuickOutput.js
+++ b/src/components/Experiment/QuickOutput/QuickOutput.js
@@ -10,6 +10,10 @@ import {
semantic_segmentation,
textToText,
textToCode,
+ styleTransfer,
+ audioToText,
+ textToAudio,
+ textConversation
} from "../../../helpers/TaskIDs";
import ObjectDetection from "./Outputs/ObjectDetection/ObjectDetection";
import ImageEnhancement from "./Outputs/ImageEnhancement/ImageEnhancement";
@@ -20,6 +24,8 @@ import useBEMNaming from "../../../common/useBEMNaming";
import TextOutput from "./Outputs/Text/TextOutput";
// import { TextToCode } from "../../ModelDetailPage/ModelDetailPage.stories"; Unused
import TextToCodeOutput from "./Outputs/TextToCode/TextToCodeOutput";
+import TextConversationOutput from "./Outputs/TextConversation/TextConversationOutput";
+import StyleTransferOutput from "./Outputs/StyleTransfer/StyleTransferOutput";
const defaultProps = {
className: "quick-output",
@@ -101,6 +107,24 @@ export default function QuickOutput(givenProps) {
trial={props.trialOutput}
/>
);
+
+ // TODO: Need to add audioToText etc
+
+
+ case textConversation:
+ return (
+
+ )
+ case styleTransfer:
+ return (
+
+ )
default:
return (
<>
diff --git a/src/components/Header/Header.scss b/src/components/Header/Header.scss
index 4a765c10..a0f746a9 100644
--- a/src/components/Header/Header.scss
+++ b/src/components/Header/Header.scss
@@ -675,6 +675,12 @@
path {
fill: $azul !important;
}
+ rect {
+ stroke: $azul !important;
+ }
+ circle {
+ stroke: $azul !important;
+ }
}
&:hover, &-selected {
@@ -688,10 +694,18 @@
stroke: $azul !important;
}
.a {
- // Currently only used for audioToText icon
+ // Currently not used
// Get more icons at https://www.svgrepo.com/
stroke: $azul !important;
}
+ rect {
+ // Currently only used for audioToText icon
+ stroke: $white !important;
+ }
+ circle {
+ // Currently only used for audioToText icon
+ stroke: $white !important;
+ }
}
}
diff --git a/src/components/HomePage/TaskCard.jsx b/src/components/HomePage/TaskCard.jsx
index 1d25f709..1f5cddda 100644
--- a/src/components/HomePage/TaskCard.jsx
+++ b/src/components/HomePage/TaskCard.jsx
@@ -26,6 +26,7 @@ export function TaskCard(props) {
trialOutput={trial}
hideHeader
showLearnMoreLink
+ runTrial={runTrial}
/>
}
diff --git a/src/components/ModelDetailPage/ModelDetailPage.jsx b/src/components/ModelDetailPage/ModelDetailPage.jsx
index 46aa79a5..cb3ff8bc 100644
--- a/src/components/ModelDetailPage/ModelDetailPage.jsx
+++ b/src/components/ModelDetailPage/ModelDetailPage.jsx
@@ -10,6 +10,7 @@ import {
instance_segmentation,
object_detection,
semantic_segmentation,
+ styleTransfer,
textToText,
textToCode,
audioToText,
@@ -24,6 +25,7 @@ import {
SampleTextToCodeInputs,
SampleAudioToTextInputs,
SampleTextConversationInputs,
+ SampleStyleTransferInputs,
} from "../../helpers/sampleImages"; // This file should be renamed
const ModelDetailPage = (props) => {
@@ -40,6 +42,8 @@ const ModelDetailPage = (props) => {
case semantic_segmentation:
case instance_segmentation:
return SampleSegmentationInputs;
+ case styleTransfer:
+ return SampleStyleTransferInputs;
case textToText:
return SampleTextInputs;
case textToCode:
@@ -69,6 +73,7 @@ const ModelDetailPage = (props) => {
case image_classification:
case semantic_segmentation:
case instance_segmentation:
+ case styleTransfer:
default:
return "image";
}
diff --git a/src/helpers/DefaultModels.js b/src/helpers/DefaultModels.js
index c996f9ca..b34ecf19 100644
--- a/src/helpers/DefaultModels.js
+++ b/src/helpers/DefaultModels.js
@@ -1,4 +1,4 @@
-import { audioToText, textToAudio, textToText } from "./TaskIDs";
+import { audioToText, styleTransfer, textToAudio, textToText } from "./TaskIDs";
export const DefaultImageClassificationModel = {
id: 1,
@@ -225,6 +225,59 @@ export const DefaultInstanceSegmentationModel = {
version: "1.0",
};
+// Note, this is a copy/paste of Image Segmentation
+export const DefaultStyleTransferModel = {
+ id: 184,
+ created_at: "2022-04-29T20:48:47.370171Z",
+ updated_at: "2022-04-29T20:48:47.370171Z",
+ attributes: {
+ Top1: "",
+ Top5: "",
+ kind: "CNN",
+ manifest_author: "Jingning Tang",
+ training_dataset: "PASCAL VOC 2012",
+ },
+ description:
+ "TensorFlow Style Transfer model, which is trained on the COCO (Common Objects in Context) dataset. Use deeplabv3_mnv2_dm05_pascal_train_aug(deeplabv3_mnv2_dm05_pascal_train_aug_2018_10_01) from TensorFlow DeepLab Model Zoo.\n",
+ short_description:
+ "DeepLabv3 is a deep convolutional neural networks for semantic image segmentation. It employ atrous convolution in cascade or in parallel to capture multi-scale context by adopting multiple atrous rates.",
+ model: {
+ graph_checksum: "0336ceb67b378df8ada0efe9eadb5ac8",
+ graph_path:
+ "https://s3.amazonaws.com/store.carml.org/models/tensorflow/models/deeplabv3_mnv2_dm05_pascal_train_aug_2018_10_01/frozen_inference_graph.pb",
+ weights_checksum: "",
+ weights_path: "",
+ },
+ framework: {
+ id: 4,
+ name: "TensorFlow",
+ version: "1.14.0",
+ architectures: [
+ {
+ name: "amd64",
+ },
+ ],
+ },
+ input: {
+ description: "",
+ type: "",
+ },
+ license: "Apache License, Version 2.0",
+ name: "DeepLabv3_MobileNet_v2_DM_05_PASCAL_VOC_Train_Aug",
+ output: {
+ description: "the output semantic segment",
+ type: styleTransfer,
+ },
+ url: {
+ github:
+ "https://github.com/rai-project/tensorflow/blob/master/builtin_models/DeepLabv3_MobileNet_v2_DM_05_PASCAL_VOC_Train_Aug.yml",
+ citation: "https://arxiv.org/pdf/1802.02611v3.pdf",
+ link1: "https://arxiv.org/pdf/1706.05587.pdf",
+ link2: "",
+ },
+ version: "1.0",
+};
+
// Note, this is the same as Image Segmentation
export const DefaultTextModel = {
id: 184,
diff --git a/src/helpers/Task.js b/src/helpers/Task.js
index 410fc641..56e1afa0 100644
--- a/src/helpers/Task.js
+++ b/src/helpers/Task.js
@@ -4,6 +4,7 @@ import {
instance_segmentation,
object_detection,
semantic_segmentation,
+ styleTransfer,
textToText,
textToCode,
audioToText,
@@ -16,6 +17,9 @@ import { ReactComponent as ObjectDetection } from "../resources/icons/icon-objec
import { ReactComponent as SemanticSegmentation } from "../resources/icons/icon-semanticSegmentation.svg";
import { ReactComponent as InstanceSegmentation } from "../resources/icons/icon-instanceSegmentation.svg";
import { ReactComponent as ImageEnhancement } from "../resources/icons/icon-imageEnhancement.svg";
+import { ReactComponent as StyleTransfer } from "../resources/icons/icon-styleTransfer.svg";
+import { ReactComponent as TextToText } from "../resources/icons/icon-textToText.svg";
+import { ReactComponent as TextToCode } from "../resources/icons/icon-textToCode.svg";
import { ReactComponent as AudioToText } from "../resources/icons/icon-audioToText.svg";
import { ReactComponent as TextToAudio } from "../resources/icons/icon-textToAudio.svg";
import { ReactComponent as TextConversation } from "../resources/icons/icon-textConversation.svg";
@@ -29,13 +33,15 @@ import {
DefaultTextModel,
DefaultAudioToTextModel,
DefaultTextToAudioModel,
- DefaultTextConversationModel
+ DefaultTextConversationModel,
+ DefaultStyleTransferModel
} from "./DefaultModels";
import {
SampleImageClassificationInputs,
SampleImageEnhancementInputs,
SampleObjectDetectionInputs,
SampleSegmentationInputs,
+ SampleStyleTransferInputs,
} from "./sampleImages";
import { TestImageClassificationResult } from "../components/Experiment/QuickOutput/Outputs/Classification/Features";
import { TestImageEnhancementData } from "../components/Experiment/QuickOutput/Outputs/ImageEnhancement/testData/TestFeatures";
@@ -47,6 +53,7 @@ import { TestAudioToTextOutput } from "../components/Experiment/QuickOutput/Outp
import { TestTextToAudioOutput } from "../components/Experiment/QuickOutput/Outputs/TextToAudio/testData/testTextToAudioOutput";
import { TestTextConversationOutput } from "../components/Experiment/QuickOutput/Outputs/TextConversation/testData/testTextConversationOutput";
import { TaskInputTypes } from "./TaskInputTypes";
+import { TestStyleTransferOutput } from "../components/Experiment/QuickOutput/Outputs/StyleTransfer/testData/testStyleTransferOutput";
export default class Task {
static image_classification = new Task({
@@ -118,13 +125,46 @@ export default class Task {
tutorialDescription:
"Image enhancement models improve the resolution of an image, making it crisper and clearer.",
});
+ static style_transfer = new Task({
+ name: "Style Transfer",
+ description:
+ "Used to convert one image into the artistic style of a second image",
+ id: styleTransfer,
+
+ // inputText: "Old inputText",
+ // inputType: TaskInputTypes.Image,
+
+ inputs: [
+ {
+ inputText: 'have its style changed.',
+ inputType: TaskInputTypes.Image,
+
+ },
+ {
+ inputText: 'use the style from.',
+ inputType: TaskInputTypes.Image,
+ }
+
+ ],
+ useMultiInput: true,
+ // Note: This is just an example of what a config field could look like, not currently used
+ config: {
+ numWarmups: 0
+ },
+
+ outputText: "Stylized image:",
+ icon: (props) =>
,
+ sampleInputs: SampleStyleTransferInputs,
+ tutorialDescription:
+ "Style transfer models convert one image into the artistic style of the second image.",
+ });
static text_to_text = new Task({
name: "Text to Text",
description: "[insert text description here]",
id: textToText,
inputText: "[insert text input help text here]",
outputText: "[insert text output help text here]",
- icon: (props) => <>,
+ icon: (props) =>
,
sampleInputs: [],
tutorialDescription: "[insert text tutorial page description here]",
inputType: TaskInputTypes.Text,
@@ -135,7 +175,7 @@ export default class Task {
id: textToCode,
inputText: "[insert text to code input help text here]",
outputText: "[insert text to code output help text here]",
- icon: (props) => <>,
+ icon: (props) =>
,
sampleInputs: [],
tutorialDescription: "[insert text to code tutorial page description here]",
inputType: TaskInputTypes.Text,
@@ -183,6 +223,9 @@ export default class Task {
this.description = options.description ?? "";
this.modelDescription = options.modelDescription ?? this.description;
this.inputText = options.inputText ?? "";
+ this.inputs = options.inputs ?? []; // TODO: Update this to be only input-related field, and remove inputText and inputType
+ this.useMultiInput = options.useMultiInput ?? false;
+ this.multiple = options.multiple ?? false; // This is used to allow multiple selections from one input
this.outputText = options.outputText ?? "";
this.Icon = options.icon ?? ((props) => <>);
this.defaultModel = Task.getDefaultModel(this.id);
@@ -209,6 +252,8 @@ export default class Task {
case instance_segmentation:
case Task.image_instance_segmentation.name:
return Task.image_instance_segmentation;
+ case styleTransfer:
+ return Task.style_transfer;
case textToText:
return Task.text_to_text;
case textToCode:
@@ -236,6 +281,8 @@ export default class Task {
return DefaultSemanticSegmentationModel;
case instance_segmentation:
return DefaultInstanceSegmentationModel;
+ case styleTransfer:
+ return DefaultStyleTransferModel;
case textToText:
return DefaultTextModel;
case textToCode:
@@ -265,6 +312,8 @@ export default class Task {
return TestImageSegmentationResult;
case instance_segmentation:
return TestInstanceSegmentationOutput;
+ case styleTransfer:
+ return TestStyleTransferOutput;
case textToText:
return TestTextOutput;
case audioToText:
@@ -285,11 +334,12 @@ export default class Task {
this.getStaticTask(image_enhancement),
this.getStaticTask(semantic_segmentation),
this.getStaticTask(instance_segmentation),
+ this.getStaticTask(styleTransfer),
this.getStaticTask(textToText),
this.getStaticTask(textToCode),
+ this.getStaticTask(textConversation),
+ this.getStaticTask(textToAudio),
this.getStaticTask(audioToText),
- this.getStaticTask(textToAudio),
- this.getStaticTask(textConversation)
];
}
diff --git a/src/helpers/TaskIDs.js b/src/helpers/TaskIDs.js
index 487b2ed6..26c2cdf7 100644
--- a/src/helpers/TaskIDs.js
+++ b/src/helpers/TaskIDs.js
@@ -3,6 +3,7 @@ export const image_enhancement = "image_enhancement";
export const object_detection = "image_object_detection";
export const semantic_segmentation = "image_semantic_segmentation";
export const instance_segmentation = "image_instance_segmentation";
+export const styleTransfer = "style_transfer";
export const textToText = "text_to_text";
export const textToCode = "text_to_code";
export const audioToText = "audio_to_text";
diff --git a/src/helpers/UppyFileTypeCheckerPlugin.js b/src/helpers/UppyFileTypeCheckerPlugin.js
index 5bbee3a2..642009a1 100644
--- a/src/helpers/UppyFileTypeCheckerPlugin.js
+++ b/src/helpers/UppyFileTypeCheckerPlugin.js
@@ -1,6 +1,6 @@
import Uppy from '@uppy/core';
-import { audioToText, image_classification, image_enhancement, object_detection, semantic_segmentation } from './TaskIDs';
+import { audioToText, image_classification, image_enhancement, object_detection, semantic_segmentation, styleTransfer } from './TaskIDs';
import fileTypeChecker from "file-type-checker";
@@ -15,6 +15,7 @@ export const getAllowedFileTypes = (task) => {
case image_enhancement:
case object_detection:
case semantic_segmentation:
+ case styleTransfer:
return {
fileTypes: ['bmp', 'gif', 'ico', 'jpeg', 'pdf', 'png', 'psd'],
mimeTypes: ['image/*']
diff --git a/src/helpers/sampleImages.js b/src/helpers/sampleImages.js
index 11c5c4af..f137589d 100644
--- a/src/helpers/sampleImages.js
+++ b/src/helpers/sampleImages.js
@@ -73,6 +73,37 @@ export const SampleInstanceSegmentationInputs = [
},
];
+export const SampleStyleTransferInputs = [
+ [
+ {
+ src: "https://s3.amazonaws.com/uploads.staging.mlmodelscope.org/person-dog.jpg",
+ alt: "person with a dog",
+ },
+ {
+ src: "https://s3.amazonaws.com/uploads.staging.mlmodelscope.org/puppies.jpg",
+ alt: "puppies",
+ },
+ {
+ src: "https://s3.amazonaws.com/uploads.staging.mlmodelscope.org/plane-blue.jpg",
+ alt: "airplane",
+ },
+ ],
+ [
+ {
+ src: "https://s3.amazonaws.com/uploads.staging.mlmodelscope.org/birdy.png",
+ alt: "bird",
+ },
+ {
+ src: "https://s3.amazonaws.com/uploads.staging.mlmodelscope.org/kitty.png",
+ alt: "cat",
+ },
+ {
+ src: "https://s3.amazonaws.com/uploads.staging.mlmodelscope.org/crabby.png",
+ alt: "crab",
+ },
+ ]
+];
+
export const SampleTextInputs = [
"Lorem ipsum dolor sit amet",
"Consectetur adipiscing elit",
diff --git a/src/resources/icons/icon-audioToText.svg b/src/resources/icons/icon-audioToText.svg
index ff858eeb..dce98fb6 100644
--- a/src/resources/icons/icon-audioToText.svg
+++ b/src/resources/icons/icon-audioToText.svg
@@ -1,18 +1,21 @@
-