diff --git a/docs/examples/ex_construct.py b/docs/examples/ex_construct.py
new file mode 100644
--- /dev/null
+++ b/docs/examples/ex_construct.py
@@ -0,0 +1,27 @@
+from pydantic import BaseModel
+
+class User(BaseModel):
+    id: int
+    age: int
+    name: str = 'John Doe'
+
+original_user = User(id=123, age=32)
+
+user_data = original_user.dict()
+print(user_data)
+fields_set = original_user.__fields_set__
+print(fields_set)
+
+# ...
+# pass user_data and fields_set to RPC or save to the database etc.
+# ...
+
+# you can then create a new instance of User without
+# re-running validation which would be unnecessary at this point:
+new_user = User.construct(_fields_set=fields_set, **user_data)
+print(repr(new_user))
+print(new_user.__fields_set__)
+
+# construct can be dangerous, only use it with validated data!:
+bad_user = User.construct(id='dog')
+print(repr(bad_user))
diff --git a/pydantic/main.py b/pydantic/main.py
--- a/pydantic/main.py
+++ b/pydantic/main.py
@@ -439,14 +439,16 @@ def from_orm(cls: Type['Model'], obj: Any) -> 'Model':
         return m
 
     @classmethod
-    def construct(cls: Type['Model'], values: 'DictAny', fields_set: 'SetStr') -> 'Model':
+    def construct(cls: Type['Model'], _fields_set: Optional['SetStr'] = None, **values: Any) -> 'Model':
         """
-        Creates a new model and set __dict__ without any validation, thus values should already be trusted.
-        Chances are you don't want to use this method directly.
+        Creates a new model setting __dict__ and __fields_set__ from trusted or pre-validated data.
+        Default values are respected, but no other validation is performed.
         """
         m = cls.__new__(cls)
-        object.__setattr__(m, '__dict__', values)
-        object.__setattr__(m, '__fields_set__', fields_set)
+        object.__setattr__(m, '__dict__', {**deepcopy(cls.__field_defaults__), **values})
+        if _fields_set is None:
+            _fields_set = set(values.keys())
+        object.__setattr__(m, '__fields_set__', _fields_set)
         return m
 
     def copy(
@@ -491,7 +493,11 @@ def copy(
 
         if deep:
             v = deepcopy(v)
-        m = self.__class__.construct(v, self.__fields_set__.copy())
+
+        cls = self.__class__
+        m = cls.__new__(cls)
+        object.__setattr__(m, '__dict__', v)
+        object.__setattr__(m, '__fields_set__', self.__fields_set__.copy())
         return m
 
     @classmethod

I am also very interested in this question, as in many cases in my code I *know* the values are correct and don't require validation. It would also be nice to have an API for initializing a model instance from known-valid inputs without needing to go through the various alias-lookups etc.

In general though I wouldn't want to disable the validation at the *model* level, but rather on a per-initialization basis. (So a separate classmethod for initializing from known-valid values would be nice.)

I *think* this is possible in one way or another; I'll see if I can make any progress.

----

@prostomarkeloff if you really do want "models" with validation completely disabled under all circumstances, you might try using vanilla dataclasses?
Okay, yes, I got this working (based on `BaseModel.validate`):

The following method could be added to your model subclass if you want to do 100% unvalidated assignment (beyond checking field names and falling back to default values):
```python
    @classmethod
    def unvalidated(__pydantic_cls__: "Type[Model]", **data: Any) -> "Model":
        for name, field in __pydantic_cls__.__fields__.items():
            try:
                data[name]
            except KeyError:
                if field.required:
                    raise TypeError(f"Missing required keyword argument {name!r}")
                if field.default is None:
                    # deepcopy is quite slow on None
                    value = None
                else:
                    value = deepcopy(field.default)
                data[name] = value
        self = __pydantic_cls__.__new__(__pydantic_cls__)
        object.__setattr__(self, "__dict__", data)
        object.__setattr__(self, "__fields_set__", set(data.keys()))
        return self
```

I did some performance tests and for data-heavy models, and the performance difference is enormous:

<details>
    <summary>Click to expand the benchmark script</summary>

```python
from contextlib import contextmanager
import time
from datetime import datetime
from typing import List, Dict, Iterator

from pydantic import BaseModel


class DoubleNestedModel(BaseModel):
    number: int
    message: str


class SubDoubleNestedModel(DoubleNestedModel):
    timestamps: List[datetime]


class NestedModel(BaseModel):
    number: int
    message: str
    double_nested: DoubleNestedModel


class SubNestedModel(NestedModel):
    timestamps: List[datetime]


class Model(BaseModel):
    nested: List[Dict[str, NestedModel]]


class SubModel(Model):
    other_nested: Dict[str, List[NestedModel]]
    timestamps: List[datetime]


def get_sub_model(timestamp: datetime) -> SubModel:
    timestamps = [timestamp] * 5
    sub_double_nested = SubDoubleNestedModel(number=1, message="a", timestamps=timestamps)
    sub_nested = SubNestedModel(number=2, message="b", double_nested=sub_double_nested, timestamps=timestamps)

    nested = [{letter: sub_nested for letter in 'abcdefg'}]
    other_nested = {letter: [sub_nested] * 5 for letter in 'abcdefg'}
    return SubModel(nested=nested, other_nested=other_nested, timestamps=timestamps)


def get_sub_model_unvalidated(timestamp: datetime) -> SubModel:
    timestamps = [timestamp] * 5
    sub_double_nested = SubDoubleNestedModel.unvalidated(number=1, message="a", timestamps=timestamps)
    sub_nested = SubNestedModel.unvalidated(number=2, message="b", double_nested=sub_double_nested,
                                            timestamps=timestamps)

    nested = [{letter: sub_nested for letter in 'abcdefg'}]
    other_nested = {letter: [sub_nested] * 5 for letter in 'abcdefg'}
    return SubModel.unvalidated(nested=nested, other_nested=other_nested, timestamps=timestamps)


@contextmanager
def basic_profile(label: str) -> Iterator[None]:
    t0 = time.time()
    yield
    t1 = time.time()
    print(f"{label}: {(t1 - t0):,.3f}s")


def run():
    n_warmup_runs = 1000
    n_runs = 10000

    timestamp = datetime.utcnow()
    sub_model = get_sub_model(timestamp)
    unvalidated_sub_model = get_sub_model_unvalidated(timestamp)

    assert sub_model == unvalidated_sub_model

    for _ in range(n_warmup_runs):
        get_sub_model(timestamp)
        get_sub_model_unvalidated(timestamp)

    with basic_profile("validated"):
        for _ in range(n_runs):
            get_sub_model(timestamp)

    with basic_profile("unvalidated"):
        for _ in range(n_runs):
            get_sub_model_unvalidated(timestamp)


run()
```
</details>

The result:
```
validated: 2.918s
unvalidated: 0.083s
```
That's a 35x speedup. Not surprising, given that validators are called on each list element / dict value. But given the performance benefits I think it may be worth using an API like this if you know it's safe. Currently it's probably bit risky due to the lack of type checking, but it would be very easy to use a mypy plugin to set the signature in the same way currently done in https://github.com/samuelcolvin/pydantic/pull/722 for the `__init__` function. So I think this could be supported in a statically checked way. (Note: this would not call any custom validators or similar.)

Note: in my testing, removing the field checks and default value inference sped things up even further to an ~43x speedup, but I think having the field and default checks are worthwhile.

@samuelcolvin do you think there is any room for a method like this on the `BaseModel` class in pydantic proper? (Maybe with a little more polish in case I'm mishandling some edge cases?) Or do you think this should be left to users to implement at their own risk?
This is what `construct` is for:

https://github.com/samuelcolvin/pydantic/blob/6cda388c7a1af29d17973f72dfebd98cff626988/pydantic/main.py#L417

It definitely needs documenting but I don't think we need a new method.

If it's signature needs changing to do what you want, we should do that pre v1 if possible.
@samuelcolvin I wasn't aware of that, that's nice.

It seems to me that 1) support for default values, and 2) not needing to manually specify the `fields_set` would go a long way toward making it more of a drop in replacement for `__init__` when the input data is known-valid.

I think it would be easier to justify the refactor efforts (in a pydantic-using codebase where I want to use `construct` for performance reasons) if it was literally just a matter of adding `.construct` for the speed up, as opposed to the more potentially involved refactor currently required.
I would be in favor of a private method like `_construct` instead of what is currently called `construct`, and have `construct` use defaults if missing and set the `fields_set` based on the keyword arguments provided.

I would also understand if you didn't want to add a breaking API change this far into the 1.0 beta. I would definitely be in favor of adding the above-described functionality though even if it needs to be a different method name or a private call. But I can always just define it on custom base class, so it's not the end of the world.
> I am also very interested in this question, as in many cases in my code I _know_ the values are correct and don't require validation. It would also be nice to have an API for initializing a model instance from known-valid inputs without needing to go through the various alias-lookups etc.
> 
> In general though I wouldn't want to disable the validation at the _model_ level, but rather on a per-initialization basis. (So a separate classmethod for initializing from known-valid values would be nice.)
> 
> I _think_ this is possible in one way or another; I'll see if I can make any progress.
> 
> @prostomarkeloff if you really do want "models" with validation completely disabled under all circumstances, you might try using vanilla dataclasses?

Thank you for answer! What about dataclasses? Firstly, i don't want to mix really different libraries in one project, secondly, dataclasses slower than pydantic. Some models in my project need this feature.
diff --git a/tests/test_construction.py b/tests/test_construction.py
--- a/tests/test_construction.py
+++ b/tests/test_construction.py
@@ -12,18 +12,27 @@ class Model(BaseModel):
 
 
 def test_simple_construct():
-    m = Model.construct(dict(a=40, b=10), {'a', 'b'})
-    assert m.a == 40
+    m = Model.construct(a=3.14)
+    assert m.a == 3.14
     assert m.b == 10
+    assert m.__fields_set__ == {'a'}
+    assert m.dict() == {'a': 3.14, 'b': 10}
 
 
-def test_construct_missing():
-    m = Model.construct(dict(a='not a float'), {'a'})
-    assert m.a == 'not a float'
-    with pytest.raises(AttributeError) as exc_info:
-        print(m.b)
+def test_construct_misuse():
+    m = Model.construct(b='foobar')
+    assert m.b == 'foobar'
+    assert m.dict() == {'b': 'foobar'}
+    with pytest.raises(AttributeError, match="'Model' object has no attribute 'a'"):
+        print(m.a)
 
-    assert "'Model' object has no attribute 'b'" in exc_info.value.args[0]
+
+def test_construct_fields_set():
+    m = Model.construct(a=3.0, b=-1, _fields_set={'a'})
+    assert m.a == 3
+    assert m.b == -1
+    assert m.__fields_set__ == {'a'}
+    assert m.dict() == {'a': 3, 'b': -1}
 
 
 def test_large_any_str():
diff --git a/tests/test_edge_cases.py b/tests/test_edge_cases.py
--- a/tests/test_edge_cases.py
+++ b/tests/test_edge_cases.py
@@ -554,7 +554,7 @@ class Model(BaseModel):
 
     assert Model(a=1, field_set=2).dict() == {'a': 1, 'field_set': 2, 'b': 3}
     assert Model(a=1, field_set=2).dict(exclude_unset=True) == {'a': 1, 'field_set': 2}
-    assert Model.construct(dict(a=1, field_set=3), {'a', 'field_set'}).dict() == {'a': 1, 'field_set': 3}
+    assert Model.construct(a=1, field_set=3).dict() == {'a': 1, 'field_set': 3, 'b': 3}
 
 
 def test_values_order():

Disable all validations
# Question

Please complete:
* OS: Ubuntu 18.04
* Python version `import sys; print(sys.version)`:
3.7.3 (default, Apr  3 2019, 19:16:38) 
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]]
* Pydantic version `import pydantic; print(pydantic.VERSION)`: 0.32.2

Hello anyone,
It possible to disable all validations of incoming data?

```py
import pydantic

class MyModel(pydantic.BaseModel):
    class Config:
        validation = False

...
```


tests/test_construction.py::test_simple_construct tests/test_construction.py::test_construct_misuse tests/test_construction.py::test_construct_fields_set tests/test_edge_cases.py::test_field_set_field_name
tests/test_construction.py::test_large_any_str tests/test_construction.py::test_simple_copy tests/test_construction.py::test_deep_copy tests/test_construction.py::test_copy_exclude tests/test_construction.py::test_copy_include tests/test_construction.py::test_copy_include_exclude tests/test_construction.py::test_copy_advanced_exclude tests/test_construction.py::test_copy_advanced_include tests/test_construction.py::test_copy_advanced_include_exclude tests/test_construction.py::test_copy_update tests/test_construction.py::test_copy_set_fields tests/test_construction.py::test_simple_pickle tests/test_construction.py::test_recursive_pickle tests/test_construction.py::test_immutable_copy tests/test_construction.py::test_pickle_fields_set tests/test_construction.py::test_copy_update_exclude tests/test_edge_cases.py::test_str_bytes tests/test_edge_cases.py::test_str_bytes_none tests/test_edge_cases.py::test_union_int_str tests/test_edge_cases.py::test_union_priority tests/test_edge_cases.py::test_typed_list tests/test_edge_cases.py::test_typed_set tests/test_edge_cases.py::test_dict_dict tests/test_edge_cases.py::test_typed_dict[value0-result0] tests/test_edge_cases.py::test_typed_dict[value1-result1] tests/test_edge_cases.py::test_typed_dict[value2-result2] tests/test_edge_cases.py::test_typed_dict_error[1-errors0] tests/test_edge_cases.py::test_typed_dict_error[value1-errors1] tests/test_edge_cases.py::test_typed_dict_error[value2-errors2] tests/test_edge_cases.py::test_dict_key_error tests/test_edge_cases.py::test_tuple tests/test_edge_cases.py::test_tuple_more tests/test_edge_cases.py::test_tuple_length_error tests/test_edge_cases.py::test_tuple_invalid tests/test_edge_cases.py::test_tuple_value_error tests/test_edge_cases.py::test_recursive_list tests/test_edge_cases.py::test_recursive_list_error tests/test_edge_cases.py::test_list_unions tests/test_edge_cases.py::test_recursive_lists tests/test_edge_cases.py::test_str_enum tests/test_edge_cases.py::test_any_dict tests/test_edge_cases.py::test_infer_alias tests/test_edge_cases.py::test_alias_error tests/test_edge_cases.py::test_annotation_config tests/test_edge_cases.py::test_success_values_include tests/test_edge_cases.py::test_include_exclude_unset tests/test_edge_cases.py::test_include_exclude_defaults tests/test_edge_cases.py::test_skip_defaults_deprecated tests/test_edge_cases.py::test_advanced_exclude tests/test_edge_cases.py::test_advanced_value_inclide tests/test_edge_cases.py::test_advanced_value_exclude_include tests/test_edge_cases.py::test_field_set_ignore_extra tests/test_edge_cases.py::test_field_set_allow_extra tests/test_edge_cases.py::test_values_order tests/test_edge_cases.py::test_inheritance tests/test_edge_cases.py::test_invalid_type tests/test_edge_cases.py::test_valid_string_types[a tests/test_edge_cases.py::test_valid_string_types[some tests/test_edge_cases.py::test_valid_string_types[value2-foobar] tests/test_edge_cases.py::test_valid_string_types[123-123] tests/test_edge_cases.py::test_valid_string_types[123.45-123.45] tests/test_edge_cases.py::test_valid_string_types[value5-12.45] tests/test_edge_cases.py::test_valid_string_types[True-True] tests/test_edge_cases.py::test_valid_string_types[False-False] tests/test_edge_cases.py::test_valid_string_types[a10-a10] tests/test_edge_cases.py::test_valid_string_types[whatever-whatever] tests/test_edge_cases.py::test_invalid_string_types[value0-errors0] tests/test_edge_cases.py::test_invalid_string_types[value1-errors1] tests/test_edge_cases.py::test_inheritance_config tests/test_edge_cases.py::test_partial_inheritance_config tests/test_edge_cases.py::test_annotation_inheritance tests/test_edge_cases.py::test_string_none tests/test_edge_cases.py::test_alias_camel_case tests/test_edge_cases.py::test_get_field_info_inherit tests/test_edge_cases.py::test_return_errors_ok tests/test_edge_cases.py::test_return_errors_error tests/test_edge_cases.py::test_optional_required tests/test_edge_cases.py::test_invalid_validator tests/test_edge_cases.py::test_unable_to_infer tests/test_edge_cases.py::test_multiple_errors tests/test_edge_cases.py::test_pop_by_alias tests/test_edge_cases.py::test_validate_all tests/test_edge_cases.py::test_force_extra tests/test_edge_cases.py::test_illegal_extra_value tests/test_edge_cases.py::test_multiple_inheritance_config tests/test_edge_cases.py::test_submodel_different_type tests/test_edge_cases.py::test_self tests/test_edge_cases.py::test_self_recursive[BaseModel] tests/test_edge_cases.py::test_self_recursive[BaseSettings] tests/test_edge_cases.py::test_nested_init[BaseModel] tests/test_edge_cases.py::test_nested_init[BaseSettings] tests/test_edge_cases.py::test_values_attr_deprecation tests/test_edge_cases.py::test_init_inspection tests/test_edge_cases.py::test_type_on_annotation tests/test_edge_cases.py::test_assign_type tests/test_edge_cases.py::test_optional_subfields tests/test_edge_cases.py::test_not_optional_subfields tests/test_edge_cases.py::test_scheme_deprecated tests/test_edge_cases.py::test_population_by_alias tests/test_edge_cases.py::test_fields_deprecated tests/test_edge_cases.py::test_alias_child_precedence tests/test_edge_cases.py::test_alias_generator_parent tests/test_edge_cases.py::test_optional_field_constraints tests/test_edge_cases.py::test_field_str_shape tests/test_edge_cases.py::test_field_type_display[int-int] tests/test_edge_cases.py::test_field_type_display[type_1-Optional[int]] tests/test_edge_cases.py::test_field_type_display[type_2-Union[NoneType, tests/test_edge_cases.py::test_field_type_display[type_3-Union[int, tests/test_edge_cases.py::test_field_type_display[type_4-List[int]] tests/test_edge_cases.py::test_field_type_display[type_5-Tuple[int, tests/test_edge_cases.py::test_field_type_display[type_6-Union[List[int], tests/test_edge_cases.py::test_field_type_display[type_7-List[Tuple[int, tests/test_edge_cases.py::test_field_type_display[type_8-Mapping[int, tests/test_edge_cases.py::test_field_type_display[type_9-Tuple[int, tests/test_edge_cases.py::test_field_type_display[type_10-Optional[List[int]]]