[ghstack-poisoned]

Using following pattern with regex ops
```
    def pattern(a):
        y = a.relu()
        z = torch.ops.pseudo.oneof(y, ops=["relu", "sigmoid"])
        return z        
```

It will match both of the following functions 

```
    def forward(x):
        x = x.relu()
        return x.sigmoid()

    def forward(y):
        z = y.relu()
        return z.relu()
```




[ghstack-poisoned]

pseudo.any is a wildcard node that can be matched with any fx node with arbitrary number of inputs and outputs.
For example, to match relu followed by one fx node:
```
    def pattern(a):
        y = a.relu()
        z = torch.ops.pseudo.any(y)
        return z
```


pseudo.oneof is a special node that can be matched with a fx node whose target is in the permissible list.
`targets` must be be a list of qualified name for operators, e.g. ["operator.add", "torch.sigmoid",
"torch.ops.aten.foo", "torch.ops.prims.bar"]

For example, using following pattern with pseudo.oneof
```
    def pattern(a):
        y = a.relu()
        z = torch.ops.pseudo.oneof(y, targets=["relu", "torch.sigmoid", "operator.add"])
        return z
```

It will have 3 matches in the following function
```
    def forward(y):
        z = y.relu()
        x = z.relu()    # first match

        x = x.relu()
        x = torch.sigmoid(x)    # second match

        x = x.relu()
        return x + 1    # third match
```

[ghstack-poisoned]